neumannTraceElement3d.hh

Go to the documentation of this file.

 
#ifndef hp3dntelement3d_hh
#define hp3dntelement3d_hh
 
#include "toolbox/sequence.hh"
#include "toolbox/sharedPointer.hh"
 
#include "integration/shapefunction.hh"
#include "space/space.hh"
#include "space/element.hh"
#include "hp2D/quad.hh"
#include "hp3D/hexFunctions.hh"
#include "hp3D/element.hh"
 
namespace hp3D{
 
  using concepts::Real;
 
  // forward declaration
  class Hexahedron;
 
 
  // **************************************************** NeumannTraceElement **
 
  template<class F = Real>
  class NeumannTraceElement3d : public hp2D::Quad<F>{
  public:
    typedef concepts::ElementAndFacette<hp3D::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:
//      /** Constructor
//
//      @param N Number of Shapefunctions
//          @param nP Number of points in which the shape functions are evaluated
//      */
//      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 << "NeumannTraceElement::NTShapeFunction(n = " << n()
//                  << ", nP = " << nP() << ", values = "
//                  << concepts::Array<Real>(values_, n()*nP()) << ')';
//      }
//    };
 
 
 
    struct mapPart{
 
      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::Cell2* coarseCellpart, Real t0, Real t1 ):coarseCell(coarseCellpart),t0(t0), t1(t1){};
 
 
 
 
        //coarse cell mapping
      const concepts::Cell2* coarseCell;
      Real t0;
      Real t1;
 
    };
 
 
 
 
    NeumannTraceElement3d( concepts::QuadNd& cell,const ushort* p /*,const mapPart* coarseCell=0*/)
        : hp2D::Quad<F>(cell,p,0,0),  T_(0), shpfct_(nullptr), isComputed_(false){};
 
    //Decontructor
    virtual ~NeumannTraceElement3d();
 
    virtual const concepts::TMatrix<F>& T() const { return T_; }
 
    /* Uses instead method of parent class
    virtual const concepts::ElementGraphics<F>* graphics() const{};
    */
 
    void computeShpfctVals(const concepts::Real2d &xP, concepts::Array<Real>& val) const;
 
 
 
 
 
  void buildT();
 
//    /// Returns the shape functions
//    const concepts::ShapeFunction1D<Real>* shpfct() {
//      //if not yet computed, first time compute them
//      if(!isComputed_)
//        recomputeShapefunctions();
//      return shpfct_.get(); }
 
   const concepts::Sequence<UnderlyingElement>& uelm()const { return uelm_;}
 
 
    void addElement(const hp3D::Hexahedron& hex, uint k,
                    Real weight = 1.0);
 
 
 
 protected:
    virtual std::ostream& info(std::ostream& os) const;
 
 
  private:
 
    // T matrix of the element
       concepts::TMatrix<Real> T_;
 
    // The shape functions, computed on quadrature points
    std::unique_ptr<concepts::ShapeFunction1D<Real> > shpfct_;
 
    //holding information if element's shapefunctions were already evaluated, this is false by default
    bool isComputed_;
 
    concepts::Sequence<UnderlyingElement> uelm_;
 
    mutable concepts::Array<Real> values_;
 
    concepts::Sequence<Real> weights_;
 
 
    mapPart coarseCell_;
    //flag if element has irregular uelms
   // bool irregular_;
 
    void compute_(const concepts::Real2d &q, concepts::Array<Real>& val) const;
 
 
 
    // void irregularCompute_(const concepts::Array<Real>& q, concepts::Array<Real>& val) const;
 
  };
 
} // namespace hp2D
 
#endif // hp2dntelement_hh