traces.hh

Go to the documentation of this file.

 
#ifndef hp2dedge_traces_hh
#define hp2dedge_traces_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 "hp2Dedge/quad.hh"
#include "hp2Dedge/edge.hh"
 
 
namespace concepts {
 
  // forward declaration
  class EdgeNormalVectorRule;
}
 
namespace hp2Dedge {
 
  using concepts::Real;
 
  // forward declaration
  template<typename F>
  class Quad;
 
 
  // ************************************************************ TraceSpace **
 
  class TraceSpace : public concepts::SpaceOnCells<Real> {
  public:
    typedef concepts::Scan<hp1D::BaseElement<Real> > Scan;
    typedef concepts::ElementAndFacette<hp2D::Element<Real> > UnderlyingElement;
 
    enum traceTypes { FIRST, MEAN, JUMP };
 
    TraceSpace(const concepts::SpaceOnCells<Real>& spc,
               const concepts::Set<uint> edgeAttr,
               enum traceTypes type = FIRST,
               const concepts::EdgeNormalVectorRule&
               normalVectorRule = concepts::EdgeNormalVectorRule());
 
    TraceSpace(concepts::SpaceOnCells<Real>& spc,
               const concepts::CellConditions* cc = 0,
               enum traceTypes type = FIRST,
               const concepts::EdgeNormalVectorRule
               normalVectorRule = concepts::EdgeNormalVectorRule());
    TraceSpace(const concepts::SpaceOnCells<Real>& spc,
               const concepts::CellConditions* cc = 0,
               enum traceTypes type = FIRST,
               const concepts::EdgeNormalVectorRule
               normalVectorRule = concepts::EdgeNormalVectorRule());
 
    virtual ~TraceSpace();
 
    virtual uint dim() const { return dim_; }
 
    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
    {
      concepts::HashMap<concepts::Sequence<UnderlyingElement> >::
        const_iterator i = uelm_.find(edge.key());
      if (i == uelm_.end())
        return concepts::Sequence<UnderlyingElement>();
      return i->second;
    }
 
    const concepts::HashMap<concepts::Sequence<UnderlyingElement> > 
    uelm() const
    {
      return 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_;
 
    concepts::HashMap<concepts::Sequence<UnderlyingElement> > uelm_;
 
    concepts::HashMap<hp1D::LegendreElement<Real>* > edges_;
    
    std::unique_ptr<QuadEdgeBase> quadEdge_;
 
    bool warn_edgeBuildMissElem_;
 
    void constructType_(enum traceTypes type,
                        const concepts::EdgeNormalVectorRule& normalVectorRule);
 
    template<class F>
    bool build_(const Quad<Real>* elm, F condition);
 
    template<class F>
    void test_(const concepts::ElementWithCell<Real>& elm, F condition);
  };
 
} // namespace hp2Dedge
 
 
#endif // hp2dedge_traces_hh