neumannTrace.hh

Go to the documentation of this file.

 
#ifndef hp2dneumanntrace_hh
#define hp2dneumanntrace_hh
 
#include "toolbox/sequence.hh"
#include "integration/shapefunction.hh"
#include "space/space.hh"
#include "space/element.hh"
#include "vectorial/vectorial.hh"
#include "hp1D/element.hh"
#include "hp2D/quad.hh"
 
namespace hp2D {
 
  using concepts::Real;
 
  // forward declaration
  template<typename F>
  class Quad;
 
  // **************************************************** NTElement_BA **
 
  template<class F = Real>
  class NTElement_BA : public concepts::ElementWithCell<F>
                            , public hp1D::IntegrableElm {
  public:
    typedef concepts::ElementAndFacette<hp2D::Element<F> > UnderlyingElement;
 
    class ShapeFunction : public concepts::ShapeFunction1D<Real> {
    public:
      ShapeFunction(const uint n, const uint nP, Real* values)
        : concepts::ShapeFunction1D<Real>(n, nP)
      {
        values_ = values;
      }
    protected:
      virtual std::ostream& info(std::ostream& os) const {
        return os << concepts::typeOf(*this)<<"(n = " << n()
                  << ", nP = " << nP() << ", values = " 
                  << concepts::Array<Real>(values_, n()*nP()) << ')';
      }
    };
    
    NTElement_BA(const concepts::Edge2d& cell);
 
 
    virtual ~NTElement_BA();
 
    virtual const concepts::Edge& support() const {
      return cell_.connector(); }
    virtual concepts::Real3d vertex(uint i) const;
    virtual const concepts::Edge2d& cell() const { return cell_; }
 
    virtual const concepts::TMatrix<F>& T() const { return T_; }
    
    void recomputeShapefunctions();
 
    const concepts::ShapeFunction1D<Real>* shpfct() const { 
      return shpfct_.get(); }
    const concepts::ShapeFunction1D<Real>* shpfctD() const {
      throw(concepts::MissingFeature("not implemented"));
      return shpfctD_.get();
    }
 
 
   const concepts::Sequence<UnderlyingElement>& uelm()const { return uelm_;}
 
   const concepts::Z2 mapRho() const {return mapRho_;}
 
 
    void addElement(const hp2D::Quad<Real>& quad, uint k,
                    Real weight = 1.0);
 
    void appendT(concepts::TColumn<F>* T) {
         T_.append(T);
    }
 
    ushort p() const {
      assert(p_.size()>0);
      if(p_.size()>1)
      assert(p_[0]==p_[1]);
      return p_[0];
    }
 
  protected:
    virtual std::ostream& info(std::ostream& os) const;
 
    //vectorial:: //als unique_ptr durch new routine in tmatrix.hh
    concepts::TMatrix<Real> T_;
  private:
    const concepts::Edge2d& cell_;
    
    concepts::Sequence<UnderlyingElement> uelm_;
 
    std::unique_ptr<concepts::ShapeFunction1D<Real> > shpfct_;
    std::unique_ptr<concepts::ShapeFunction1D<Real> > shpfctD_;
    concepts::Array<Real> values_, valuesD_;
    concepts::Sequence<uint> dim_;
    concepts::Sequence<uint> p_;
    concepts::Sequence<Real> weights_;    
 
    //Orientation of the mapping, the mapping is not oriented like to topological one in general
    concepts::Z2 mapRho_;
  };
 
} // namespace hp2D
 
#endif // hp2dneumanntrace_hh