hpAdaptiveSpaceDG.hh

Go to the documentation of this file.

 
#pragma once
 
#include "toolbox/set.hh"
#include "hp2D/hpAdaptiveSpace.hh"
 
namespace hp2D {
 
  using concepts::Real;
 
  // ***************************************************** hpAdaptiveSpaceDG **
 
  template<class F>
  class hpAdaptiveSpaceDG : public concepts::SpaceOnCoarseCells<2u, Real> {
  public:
    typedef concepts::Scan<hp2D::Element<Real> > Scan;
 
    hpAdaptiveSpaceDG(concepts::Mesh2& msh, uint l, uint p,
                      concepts::Sequence<concepts::Set<uint> > domains,
                      concepts::BoundaryConditions* bc = 0,
                      bool linearTrunk = false);
 
    hpAdaptiveSpaceDG(concepts::Mesh2& msh, uint l, uint p,
                      const char* domains,
                      concepts::BoundaryConditions* bc = 0,
                      bool linearTrunk = false);
 
    hpAdaptiveSpaceDG(concepts::Mesh2& msh, uint l, uint p,
                      std::string domains,
                      concepts::BoundaryConditions* bc = 0,
                      bool linearTrunk = false);
 
    hpAdaptiveSpaceDG(hpFull& prebuild, uint spcNo,
                      concepts::Sequence<concepts::Set<uint> > domains,
                      concepts::BoundaryConditions* bc = 0,
                      bool linearTrunk = false);
 
    hpAdaptiveSpaceDG(hpFull& prebuild, uint spcNo,
                      std::string domains,
                      concepts::BoundaryConditions* bc = 0,
                      bool linearTrunk = false);
 
        hpAdaptiveSpaceDG(hpFull& prebuild, uint spcNo,
                          const char* domains,
                          concepts::BoundaryConditions* bc = 0,
                          bool linearTrunk = false);
 
    ~hpAdaptiveSpaceDG();
    inline virtual uint dim() const  { return dim_; }
    inline virtual uint nelm() const { return nelm_; }
    inline virtual Scan* scan() const {
      return new concepts::PListScan<Element<Real> >(*elm_);
    }
    
    void rebuild();
 
    void recomputeShapefunctions();
 
    const concepts::Sequence<F*> spaces() const { return spc_; }
 
    virtual const std::set<typename concepts::CellType<2u>::cell * > allCells() const ;
 
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    concepts::Sequence<F*> spc_;
  private:
  
    std::set<uint> activeCells_;
    uint dim_;
    uint nelm_;
    uint build_;
    concepts::Joiner<Element<Real>*, 1>* elm_;
    concepts::Sequence<concepts::CellConditions> cc_;
  };
 
  // **************************************************** hpAdaptiveSpaceH1_DG **
 
  typedef hpAdaptiveSpaceDG<hpAdaptiveSpaceH1> hpAdaptiveSpaceH1_DG;
 
  // ******************************************* hpAdaptiveSpaceH1_DGFromInput **
 
   hpAdaptiveSpaceH1_DG*
   hpAdaptiveSpaceH1_DGFromInput(concepts::Mesh2& msh,
                                 const concepts::InOutParameters input,
                                 bool verbose = false);
 
 
} // namespace hp2D