hpAdaptiveSpace.hh

Go to the documentation of this file.

 
#ifndef hpAdaptSpace2D_hh
#define hpAdaptSpace2D_hh
 
#include "basics/exceptions.hh"
#include "geometry/cell2D.hh"
#include "geometry/mesh.hh"
#include "geometry/boundaryConditions.hh"
#include "geometry/cellConditions.hh"
#include "space/hpMethod.hh"
#include "space/space.hh"
#include "hp2D/element.hh"
#include "hp2D/spacePreBuilder.hh"
#include "hp2D/buildTColumnsBase.hh"
 
namespace hp2D {
 
  // ******************************************************* hpAdaptiveSpace **
 
  template<class F>
  class hpAdaptiveSpace : 
    public concepts::SpaceOnCoarseCells<2, F>,
    public concepts::AdaptiveSpace<F, concepts::AdaptiveAdjustP<2> >,
    public concepts::Subspace {
  public:
    typedef concepts::Scan<hp2D::Element<F> > Scan;
    typedef F t_type;
    
    hpAdaptiveSpace(concepts::Mesh2& msh, uint l, uint p,
        concepts::BoundaryConditions* bc = 0,
        concepts::CellConditions* cc = 0);
 
    hpAdaptiveSpace(hpFull& prebuild,
        concepts::BoundaryConditions* bc = 0,
        concepts::CellConditions* cc = 0, uint spcNo = 0,
        uint* offset = 0, uint* idx = 0);
    
    hpAdaptiveSpace(const hpAdaptiveSpace& spc);
    virtual ~hpAdaptiveSpace();
    
    hpFull& prebuild() { return *prebuild_; }
    hpFull& prebuild() const { return *prebuild_; }
    
    const concepts::SubspaceHelper<F, SpacePreBuilder>& helper() const { return spc_; }
 
    concepts::SubspaceHelper<F, SpacePreBuilder>& helper() { return spc_; }
    virtual uint& lastIdx() { return spc_.idx(); }
    virtual const uint& lastIdx() const { return spc_.idx(); }
    virtual uint offset() const { return offset_; }
 
    inline virtual uint dim() const;
    inline virtual uint nelm() const;
    inline virtual Scan* scan() const;
    
    inline uint dim();
    inline uint nelm();
    inline Scan* scan();
    
    virtual void adjust(const concepts::Element<F>& elm,
      const concepts::AdaptiveAdjustP<2>& a);
 
    void rebuild(bool sameIndices = false);
    
    std::pair<bool, uint> available() const; 
 
    void set_bc(const concepts::BoundaryConditions* bc) { 
      spc_.set_bc(bc);
    }
    
    const std::set<concepts::Cell2* > allCells() const{
      return prebuild_->allCells();
    }
 
    virtual void recomputeShapefunctions() = 0;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    hpFull* const prebuild_;
    
    concepts::SubspaceHelper<F, SpacePreBuilder> spc_;
 
    uint nelm_;
 
    uint offset_;
 
    bool zeroDim_;
 
    uint idxVtx_, idxEdge_, idxInner_;
    
    virtual Element<F>* newElement_(concepts::Cell2& cell, ushort* pMax,
                                    concepts::TColumn<F>* T0,
                                    concepts::TColumn<F>* T1) const = 0;
 
    virtual concepts::TColumn<F>*
    applySmatrices_(const concepts::Element<F>& elm, uint i,
                    const concepts::TColumn<F>* T0,
                    const concepts::TColumn<F>* T1) = 0;
    
    void setBuildVertexDofs_(const BuildTColumnsBase<F>* b);
 
    void setBuildEdgeDofs_(const BuildTColumnsBase<F>* b);
 
    void setBuildInnerDofs_(const BuildTColumnsBase<F>* b);    
  private:
    bool ownPrebuild_;
    uint dofBuild_;
    uint build_;
    concepts::Joiner<Element<F>*, 1>* elm_;
    std::unique_ptr<const BuildTColumnsBase<F> > buildVertexDofs_;
    std::unique_ptr<const BuildTColumnsBase<F> > buildEdgeDofs_;
    std::unique_ptr<const BuildTColumnsBase<F> > buildInnerDofs_;
    bool notAvailable_;
    
    void buildElements_(concepts::Cell2& cell, ushort* Pmax,
      concepts::TColumn<F>* T0 = 0);
    
    template<class G>
    void setVtxPassive_(G& cntr, bool forChildren = false, bool always= false);
    
    void setEdgePassive_(const concepts::Connector1& cntr);
  };
 
  template<class F>
  uint hpAdaptiveSpace<F>::dim() const {
    if (!available().first)
      throw conceptsException(concepts::SpaceNotBuilt());
    return lastIdx() - offset();
  }
 
  template<class F>
  uint hpAdaptiveSpace<F>::nelm() const {
    if (!available().first)
      throw conceptsException(concepts::SpaceNotBuilt());
    return nelm_; 
  }
 
  template<class F>
  typename hpAdaptiveSpace<F>::Scan* hpAdaptiveSpace<F>::scan() const {
    if (!available().first)
      throw conceptsException(concepts::SpaceNotBuilt());
    return new concepts::PListScan<Element<F> >(*elm_);
  }
 
  template<class F>
  uint hpAdaptiveSpace<F>::dim() {
    if (!available().first) rebuild();
    return lastIdx() - offset();
  }
 
  template<class F>
  uint hpAdaptiveSpace<F>::nelm() {
    if (!available().first) rebuild();
    return nelm_; 
  }
  
  template<class F>
  typename hpAdaptiveSpace<F>::Scan* hpAdaptiveSpace<F>::scan() {
    if (!available().first) rebuild();
    return new concepts::PListScan<Element<F> >(*elm_);
  }
  
} // namespace hp2D
 
#endif // hpAdaptSpace2D_hh