hp2Dedge/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(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();

    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::auto_ptr<concepts::SMatrix1D>  S1left_t_, S1right_t_, S1left_n_,
      S1right_n_;

    std::auto_ptr<concepts::SMatrixBase<Real> > Smatrices2H_X_[2];
    std::auto_ptr<concepts::SMatrixBase<Real> > Smatrices2H_Y_[2];
    std::auto_ptr<concepts::SMatrixBase<Real> > Smatrices2V_X_[2];
    std::auto_ptr<concepts::SMatrixBase<Real> > Smatrices2V_Y_[2];

    std::auto_ptr<concepts::SMatrixBase<Real> > Smatrices2H_[2];
    std::auto_ptr<concepts::SMatrixBase<Real> > Smatrices2V_[2];
    std::auto_ptr<concepts::SMatrixBase<Real> > Smatrices4_[4];

  };

} // namespace hp2D

#endif // hpAdaptSpace2DHCurl_hh