neumannTraceElement.hh

Go to the documentation of this file.

 
#ifndef hp2dntelement_hh
#define hp2dntelement_hh
 
#include "toolbox/sequence.hh"
#include "toolbox/sharedPointer.hh"
 
#include "integration/shapefunction.hh"
#include "space/space.hh"
#include "space/element.hh"
#include "hp1D/element.hh"
#include "hp2D/quad.hh"
 
namespace hp2D {
 
using concepts::Real;
 
// forward declaration
template<typename F>
class Quad;
 
// **************************************************** NeumannTraceElement **
 
template<class F = Real>
class NeumannTraceElement: public hp1D::BaseElement<F> {
public:
  typedef concepts::ElementAndFacette<hp2D::Element<F> > UnderlyingElement;
 
  /*
   * Shapefunction as normal derivatives of origin basisfunctions
   * these class only represents the Shapefunctions evaluated on quadrature Points
   * since it controls if elements shapefunctions quadrature evaluation is done already
   * and if not that will be done.
   *
   * If this shapefunctions should be evaluated on certain points (e.g. in functions like hp2D::Value)
   * use the computeShpfct routine
   */
  class NTShapeFunction: public concepts::ShapeFunction1D<Real> {
  public:
    NTShapeFunction(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())
          << ')';
    }
  };
 
  //helper structure for coarse to fine edge orientation
  struct mapPart {
    //default constructor
    mapPart() :
        coarseCell(0) {
    }
    ;
    //control constructor: if pointer !=0 work as copy constructor, else like default constructor
    mapPart(const mapPart* mp) :
        coarseCell((mp) ? mp->coarseCell : 0) {
      if (mp) {
        t0 = mp->t0;
        t1 = mp->t1;
      }
    }
 
    mapPart(const concepts::EdgeNd* coarseCellpart, Real t0, Real t1) :
        coarseCell(coarseCellpart), t0(t0), t1(t1) {
    }
    ;
 
    //coarse cell mapping
    const concepts::EdgeNd* coarseCell;
    Real t0;
    Real t1;
  };
 
  NeumannTraceElement(const concepts::EdgeNd& cell, uint p,
      const mapPart* coarseCell = 0);
 
  //Decontructor
  virtual ~NeumannTraceElement();
 
  virtual const concepts::TMatrix<F>& T() const {
    return T_;
  }
 
  void computeShpfctVals(const concepts::Array<Real>& xP,
      concepts::Array<Real>& val) const;
 
  virtual void recomputeShapefunctions();
 
  void buildT();
 
  virtual const concepts::ShapeFunction1D<Real>* shpfct() const;
 
  const concepts::Sequence<UnderlyingElement>& uelm() const {
    return uelm_;
  }
 
  void addElement(const hp2D::Quad<Real>& quad, uint k, Real weight = 1.0);
 
  void addIrrElement(const hp2D::Quad<Real>& coarseQuad, uint k_coarse,
      Real weight);
 
protected:
  virtual std::ostream& info(std::ostream& os) const;
 
private:
 
  // The shape functions, computed on quadrature points on demand
  mutable std::unique_ptr<concepts::ShapeFunction1D<Real> > shpfct_;
 
  // T matrix of the element
  concepts::TMatrix<Real> T_;
 
  //holding information if element's shapefunctions were already evaluated, this is false by default
  //mutable bool isComputed_;
 
  //flag if element has irregular uelms
  bool irregular_;
 
  mapPart coarseCell_;
 
  concepts::Sequence<UnderlyingElement> uelm_;
 
  mutable concepts::Array<Real> values_;
 
  concepts::Sequence<Real> weights_;
 
  void compute_(const concepts::Array<Real>& q,
      concepts::Array<Real>& val) const;
 
  void irregularCompute_(const concepts::Array<Real>& q,
      concepts::Array<Real>& val) const;
 
};
 
} // namespace hp2D
 
#endif // hp2dntelement_hh