edge.hh

Go to the documentation of this file.

 
#ifndef hp2dedge_hh
#define hp2dedge_hh
 
#include <iostream>
#include <memory>
#include "basics/typedefs.hh"
#include "basics/outputOperator.hh"
#include "basics/vectorsMatrices.hh"
#include "geometry/cell1D.hh"
#include "geometry/elementMaps.hh"
#include "geometry/integral.hh"
#include "geometry/normalVector.hh"
#include "integration/quadRule.hh"
#include "space/tmatrix.hh"
#include "space/hpMethod.hh"
#include "space/integral.hh"
#include "hp1D/element.hh"
#include "integration/karniadakis.hh"
 
 
namespace hp2D {
 
  using concepts::Real;
  using concepts::Z2;
 
  // forward declaration
  template<typename F>
  class Quad;
 
  // ************************************************************ QuadEdgeBase **
 
  class QuadEdgeBase : public concepts::OutputOperator {
  public:
    QuadEdgeBase(const concepts::EdgeNormalVectorRule& 
                 normalVectorRule = concepts::EdgeNormalVectorRule())
      : normalVectorRule_(normalVectorRule.clone()) 
    {}
 
    template<class F>
    std::pair<hp1D::Element<F>*,concepts::Edge2d*> 
    edge(const Quad<F>& elm, const ushort k, bool emptyElm = true,
         hp1D::Element<F>* edge = 0);
  protected:
    virtual std::ostream& info(std::ostream& os) const;
 
    std::unique_ptr<const concepts::EdgeNormalVectorRule> normalVectorRule_;
    
    virtual Real weight_(bool first, Z2 dir) const = 0;
  private:
 
    template<class F>
    void transferDof_(const ushort* p, const ushort k, const bool rho,
                      const bool first, const Z2 dir, 
                      const concepts::TMatrix<F>& T,
                      hp1D::Element<F>& edge);
    
    bool edgeDof_(const ushort* p, const ushort k, const bool rho,
                  const uint dofQuad, uint& dofEdge);
  };
 
  // *********************************************************** QuadEdgeFirst **
 
  class QuadEdgeFirst : public QuadEdgeBase {
  public:
    QuadEdgeFirst(const concepts::EdgeNormalVectorRule& 
                  normalVectorRule = concepts::EdgeNormalVectorRule())
      : QuadEdgeBase(normalVectorRule) {}
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    virtual Real weight_(bool first, Z2 dir) const;
  };
 
  // ************************************************************ QuadEdgeMean **
 
  class QuadEdgeMean : public QuadEdgeBase {
  public:
    QuadEdgeMean(const concepts::EdgeNormalVectorRule& 
                 normalVectorRule = concepts::EdgeNormalVectorRule())
      : QuadEdgeBase(normalVectorRule) {}
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    virtual Real weight_(bool first, Z2 dir) const;
  };
 
  // ************************************************************ QuadEdgeJump **
 
  class QuadEdgeJump : public QuadEdgeBase {
  public:
    QuadEdgeJump(const concepts::EdgeNormalVectorRule& 
                 normalVectorRule = concepts::EdgeNormalVectorRule())
      : QuadEdgeBase(normalVectorRule) {}
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    virtual Real weight_(bool first, Z2 dir) const;
  };
 
} // namespace hp2D
 
#endif // hp2dedge_hh