hpAdaptiveSpaceL2.hh

Go to the documentation of this file.

 
#ifndef hpAdaptSpace2DL2_hh
#define hpAdaptSpace2DL2_hh
 
#include "basics/typedefs.hh"
#include "toolbox/inputOutput.hh"
#include "hp2D/hpAdaptiveSpace.hh"
#include "hp2D/buildL2TColumns.hh"
 
namespace hp2D {
 
  using concepts::Real;
 
  // forward declarations
  template<class F>
    class Quad;
 
  class hpAdaptiveSpaceL2;
 
  // ******************************************** hpAdaptiveSpaceL2FromInput **
 
   hpAdaptiveSpaceL2*
   hpAdaptiveSpaceL2FromInput(concepts::Mesh2& msh,
                              const concepts::InOutParameters input,
                              bool verbose = false);
 
  // ***************************************************** hpAdaptiveSpaceL2 **
 
  class hpAdaptiveSpaceL2 : public hpAdaptiveSpace<Real> {
  public:
    typedef concepts::Scan<hp2D::Element<Real> > Scan;
    
    hpAdaptiveSpaceL2(concepts::Mesh2& msh, uint l, uint p,
                      concepts::BoundaryConditions* bc = 0,
                      concepts::CellConditions* cc = 0);
    
    hpAdaptiveSpaceL2(concepts::Mesh2& msh, 
                      const concepts::InOutParameters input);
 
    hpAdaptiveSpaceL2(hpFull& prebuild, 
                      concepts::BoundaryConditions* bc = 0,
                      concepts::CellConditions* cc = 0 , uint spcNo = 0,
                      uint* offset = 0, uint* idx = 0);
    
    hpAdaptiveSpaceL2(const hpAdaptiveSpaceL2& spc);
    virtual ~hpAdaptiveSpaceL2();
    
    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;
  protected:
    virtual concepts::TColumn<Real>*
    applySmatrices_(const concepts::Element<Real>& elm, uint i,
                    const concepts::TColumn<Real>* T0,
                    const concepts::TColumn<Real>* T1);
  };
  
} // namespace hp2D
 
namespace concepts {
 
  template<>
  struct number<hp2D::hpAdaptiveSpaceL2> {
    static inline std::string name() { return "hp2D::hpAdaptiveSpaceL2"; }
  };
 
} // namespace concepts
 
#endif // hpAdaptSpace2DL2_hh