hpAdaptiveSpaceH1.hh

Go to the documentation of this file.

 
#ifndef hpAdaptSpace2DH1_hh
#define hpAdaptSpace2DH1_hh
 
#include "basics/typedefs.hh"
#include "toolbox/inputOutput.hh"
#include "hp2D/hpAdaptiveSpace.hh"
#include "hp2D/buildH1TColumns.hh"
 
namespace concepts {
 
  // forward declarations
  template<class F>
    class SMatrixBase;
 
  class SMatrix1D;
}
 
namespace hp2D {
 
  using concepts::Real;
 
  // forward declarations
  template<class F>
    class Quad;
 
  class hpAdaptiveSpaceH1;
 
  // ******************************************** hpAdaptiveSpaceH1FromInput **
 
   hpAdaptiveSpaceH1*
   hpAdaptiveSpaceH1FromInput(concepts::Mesh2& msh,
                              const concepts::InOutParameters input,
                              bool verbose = false);
 
  // ***************************************************** hpAdaptiveSpaceH1 **
 
  class hpAdaptiveSpaceH1 : public hpAdaptiveSpace<Real> {
  public:
    typedef concepts::Scan<hp2D::Element<Real> > Scan;
    
    hpAdaptiveSpaceH1(concepts::Mesh2& msh, uint l, uint p,
                      concepts::BoundaryConditions* bc = 0,
                      concepts::CellConditions* cc = 0);
    
    hpAdaptiveSpaceH1(concepts::Mesh2& msh, 
                      const concepts::InOutParameters input);
 
    hpAdaptiveSpaceH1(hpFull& prebuild, 
          concepts::BoundaryConditions* bc = 0,
          concepts::CellConditions* cc = 0 , uint spcNo = 0,
          uint* offset = 0, uint* idx = 0);
    
    hpAdaptiveSpaceH1(const hpAdaptiveSpaceH1& spc);
    virtual ~hpAdaptiveSpaceH1();
    
    void buildVertexDofs(const BuildTColumnsBase<Real>* b) {
      setBuildVertexDofs_(b);
    }
    void buildEdgeDofs(const BuildTColumnsBase<Real>* b) {
      setBuildEdgeDofs_(b);
    }
    void buildInnerDofs(const BuildTColumnsBase<Real>* b) {
      setBuildInnerDofs_(b);
    }
 
    virtual void recomputeShapefunctions();
    protected:
      virtual std::ostream& info(std::ostream& os) const;
 
    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);
  private:
    void recomputeSmatrices_(const Quad<Real>& elm);
    
    std::unique_ptr<concepts::SMatrix1D> S1left_, S1right_;
    
    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::hpAdaptiveSpaceH1> {
    static inline std::string name() { return "hp2D::hpAdaptiveSpaceH1"; }
  };
 
} // namespace concepts
 
#endif // hpAdaptSpace2DH1_hh