hpAdaptiveSpaceHCurl.hh

Go to the documentation of this file.

 
#ifndef hpAdaptSpace2DHCurl_hh
#define hpAdaptSpace2DHCurl_hh
 
#include "basics/typedefs.hh"
#include "toolbox/inputOutput.hh"
#include "formula/boundary.hh"
#include "hp2D/hpAdaptiveSpace.hh"
#include "hp2D/refinePreBuilder.hh"
#include "hp2Dedge/buildHCurlTColumns.hh"
 
namespace concepts {
 
  // forward declarations
  template<class F>
  class SMatrixBase;
 
  class SMatrix1D;
}
 
namespace hp2Dedge {
 
  // forward declarations
  template<class F>
  class Quad;
}
 
namespace hp2D {
 
  class hpAdaptiveSpaceHCurl;
 
  using concepts::Real;
 
  // ***************************************** hpAdaptiveSpaceHCurlFromInput **
 
   hpAdaptiveSpaceHCurl*
   hpAdaptiveSpaceHCurlFromInput(concepts::Mesh2& msh,
                                 const concepts::InOutParameters input,
                                 bool verbose = false);
 
  // ************************************************** hpAdaptiveSpaceHCurl **
 
  class hpAdaptiveSpaceHCurl : public hpAdaptiveSpace<Real> {
  public:
    typedef concepts::Scan<hp2D::Element<Real> > Scan;
 
    hpAdaptiveSpaceHCurl(concepts::Mesh2& msh, uint l, uint p,
                         concepts::BoundaryConditions* bc = 0,
                         concepts::CellConditions* cc = 0);
    hpAdaptiveSpaceHCurl(concepts::Mesh2& msh, 
                         const concepts::InOutParameters input);
    hpAdaptiveSpaceHCurl(hpFull& prebuild, 
       concepts::BoundaryConditions* bc = 0,
       concepts::CellConditions* cc = 0, uint spcNo = 0,
       uint* offset = 0, uint* idx = 0);
    hpAdaptiveSpaceHCurl(const hpAdaptiveSpaceHCurl& spc);
    virtual ~hpAdaptiveSpaceHCurl();
 
    virtual uint getOutputDimension() const{
      return 2u;
    }
 
    void buildEdgeDofs(const BuildTColumnsBase<Real>* b) {
      setBuildEdgeDofs_(b);
    }
    void buildInnerDofs(const BuildTColumnsBase<Real>* b) {
      setBuildInnerDofs_(b);
    }
    
    void recomputeShapefunctions();
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    virtual Element<Real>* newElement_(concepts::Cell2& cell, ushort* pMax,
                                       concepts::TColumn<Real>* T0,
                                       concepts::TColumn<Real>* T1) const;
    virtual concepts::TColumn<Real>*
    applySmatrices_(const concepts::Element<Real>& elm, uint i,
                    const concepts::TColumn<Real>* T0,
                    const concepts::TColumn<Real>* T1);
    void recomputeSmatrices_(const hp2Dedge::Quad<Real>& elm);
 
    std::unique_ptr<concepts::SMatrix1D>  S1left_t_, S1right_t_, S1left_n_,
      S1right_n_;
 
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices2H_X_[2];
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices2H_Y_[2];
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices2V_X_[2];
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices2V_Y_[2];
 
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices2H_[2];
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices2V_[2];
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices4_[4];
 
  };
 
} // namespace hp2D
 
namespace concepts {
 
  template<>
  struct number<hp2D::hpAdaptiveSpaceHCurl> {
    static inline std::string name() { return "hp2D::hpAdaptiveSpaceHCurl"; }
  };
 
} // namespace concepts
 
#endif // hpAdaptSpace2DHCurl_hh