neumannTraceSpace.hh

Go to the documentation of this file.

 
#ifndef hp2dntracespace_hh
#define hp2dntracespace_hh
 
#include "toolbox/sequence.hh"
#include "formula/boundary.hh"
#include "formula/exceptions.hh"
#include "geometry/boundaryConditions.hh"
#include "geometry/cellConditions.hh"
#include "space/space.hh"
#include "hp1D/element.hh"
#include "hp2D/element.hh"
#include "hp2D/edge.hh"
#include "hp2D/gridInfo.hh"
#include "geometry/normalVector.hh"
#include "geometry/edgeTraceTypes.hh"
 
#include "neumannTraceElement.hh"
 
namespace hp2D {
 
  using concepts::Real;
 
  // forward declaration
  template<typename F>
  class Quad;
 
 
  // ****************************************************** NeumannTraceSpace **
 
  class NeumannTraceSpace: public concepts::SpaceOnCells<Real> {
  public:
    typedef concepts::Scan<hp1D::BaseElement<Real> > Scan;
    typedef concepts::ElementAndFacette<hp2D::Element<Real> > UnderlyingElement;
    typedef concepts::ElementAndFacette<concepts::Edge> UnderlyingEdge;
 
    NeumannTraceSpace(const concepts::SpaceOnCells<Real>& spc,
          const concepts::Set<uint> edgeAttr,
          enum concepts::EdgeTraceType::traceTypes type = concepts::EdgeTraceType::FIRST,
          const concepts::EdgeNormalVectorRule& normalVectorRule =
          concepts::EdgeNormalVectorRule(), bool emptyElm = true);
 
 
    NeumannTraceSpace(const GridInfo<Real>& gInfo, uint sDim,
          enum concepts::EdgeTraceType::traceTypes type = concepts::EdgeTraceType::FIRST,
          const concepts::EdgeNormalVectorRule& normalVectorRule =
          concepts::EdgeNormalVectorRule(), bool emptyElm = true);
 
    NeumannTraceSpace(concepts::SpaceOnCells<Real>& spc,
          const concepts::EdgeTraceTypes& ettypes, bool emptyElm = true);
 
    virtual ~NeumannTraceSpace();
 
    inline virtual uint dim() const {
      return dim_;
    }
 
    inline virtual uint nelm() const {
      return nelm_;
    }
 
    virtual Scan* scan() const {
      return new concepts::PListScan<hp1D::BaseElement<Real> >(*elm_);
    }
 
    const concepts::Sequence<UnderlyingElement> uelm(
                 const concepts::Edge edge) const {
      auto i = edges_.find(edge.key());
      if (i == edges_.end())
  return concepts::Sequence<UnderlyingElement>();
      return i->second->uelm();
    }
 
    virtual void recomputeShapefunctions();
 
 
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const uint dim_;
 
    uint nelm_;
 
    concepts::Joiner<hp1D::BaseElement<Real>*, 1>* elm_;
 
    //number of irregular builded elements
    uint nIrrelm_;
 
    //flag controlling elements with no dofs in the space
    bool emptyElements_;
 
    concepts::EdgeTraceTypes trTypes_;
 
    concepts::Sequence<concepts::Edge2d*> coarseCells_;
 
    GridInfo<Real>::CoarseToSuccessor mapCtS_;
 
    concepts::HashMap<hp2D::NeumannTraceElement<Real>*> edges_;
 
    // Builds the NeumanntraceElements with Informations about the Underyling Elements
    void build_regular_(const hp2D::GridInfo<Real>& gInfo);
 
    //actually creates the irregular ELements with the help of the mappings
    void build_irregular_(const hp2D::GridInfo<Real>& gInfo);
    Real weight_(bool first, const Z2 dir, const uint nUelm,
     const concepts::Attribute attrb) const;
 
  };
 
} // namespace hp2D
 
#endif // hp2dntracespace_hh