buildDofsBase.hh

Go to the documentation of this file.

 
#ifndef buildDofsBase_hh
#define buildDofsBase_hh
 
#include "hp3D/space.hh"
 
namespace hp3D {
 
  // forward declaration
  class Space;
 
  // ********************************************************* BuildDofsBase **
 
  class BuildDofsBase {
  public:
    BuildDofsBase() : spc_(0) {}
    BuildDofsBase(Space& spc) : spc_(&spc) {}
    virtual void operator()(concepts::Hexahedron& cntr,
          concepts::TColumn<Real>*& T1) = 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 concepts::AdaptiveControlP<3>& ctrl3_(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;
    inline std::map<uint, concepts::FaceData>::const_iterator
    faceListFind(uint idx) const;
    inline std::map<uint, concepts::FaceData>::const_iterator
    faceListEnd() const;
    uint& dim_() { return spc_->dim_; }
    inline void deactivate_(const concepts::Connector0& vtx);
    inline void deactivate_(const concepts::Connector1& edg);
    inline void deactivate_(const concepts::Connector2& face);
    inline void computePmax_(const concepts::Hexahedron& cntr,
           ushort Pmax[3]) const;
    inline void getPmax_(const concepts::Hexahedron& cntr,
           ushort Pmax[3]) 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_->operator[](idx);
  }
 
  concepts::AdaptiveControlP<2>& BuildDofsBase::ctrl2_(uint idx) {
    conceptsAssert(spc_, concepts::Assertion());
    return spc_->ctrl2_->operator[](idx);
  }
 
  concepts::AdaptiveControlP<3>& BuildDofsBase::ctrl3_(uint idx) {
    conceptsAssert(spc_, concepts::Assertion());
    return spc_->ctrl3_[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();
  }
 
  std::map<uint, concepts::FaceData>::const_iterator
  BuildDofsBase::faceListFind(uint idx) const {
    conceptsAssert(spc_, concepts::Assertion());
    return spc_->faceList_.find(idx);
  }
 
  std::map<uint, concepts::FaceData>::const_iterator
  BuildDofsBase::faceListEnd() const {
    conceptsAssert(spc_, concepts::Assertion());
    return spc_->faceList_.end();
  }
 
  void BuildDofsBase::deactivate_(const concepts::Connector0& vtx) {
    conceptsAssert(spc_, concepts::Assertion());
    spc_->deactivate_(vtx);
  }
 
  void BuildDofsBase::deactivate_(const concepts::Connector1& edg) {
    conceptsAssert(spc_, concepts::Assertion());
    spc_->deactivate_(edg);
  }
 
  void BuildDofsBase::deactivate_(const concepts::Connector2& face) {
    conceptsAssert(spc_, concepts::Assertion());
    spc_->deactivate_(face);
  }
 
  void BuildDofsBase::computePmax_(const concepts::Hexahedron& cntr,
             ushort Pmax[3]) const {
    conceptsAssert(spc_, concepts::Assertion());
    spc_->computePmax_(cntr, Pmax);
  }
 
  void BuildDofsBase::getPmax_(const concepts::Hexahedron& cntr,
             ushort Pmax[3]) const {
    conceptsAssert(spc_, concepts::Assertion());
    spc_->getPmax_(cntr, Pmax);
  }  
  
} // namespace hp3D
 
#endif // buildDofsBase_hh