space.hh

Go to the documentation of this file.

 
#ifndef hpSpace2Dedge_hh
#define hpSpace2Dedge_hh
 
#include <memory>
#include <cstring>
#include <set>
#include "basics/exceptions.hh"
#include "basics/typedefs.hh"
#include "space/space.hh"
#include "space/hpMethod.hh"
#include "geometry/continuityData.hh"
#include "geometry/cell2D.hh"
#include "geometry/mesh.hh"
#include "toolbox/scannerConnectors.hh"
#include "toolbox/dynArray.hh"
#include "geometry/boundaryConditions.hh"
#include "hp2D/element.hh"
#include "hp2D/space.hh"
 
namespace concepts {
 
  // forward declarations
  template<class F>
  class SMatrixBase;
 
  class SMatrix1D;
 
  template<class F, int dim>
  class SMatrixTensor;
 
} // namespace concepts
 
namespace hp2Dedge {
  using concepts::Real;
 
  // ***************************************************************** Space **
 
  class Space : 
    public concepts::SpaceOnCells<Real>,
    public concepts::AdaptiveSpace<Real, concepts::AdaptiveAdjustP<2> > {
  public:
    typedef concepts::Scan<hp2D::Element<Real> > Scan;
 
    Space(concepts::Mesh2& msh, uint l, uint p,
    concepts::BoundaryConditions* bc = 0, bool trunk = false);
    virtual ~Space();
 
    // Override concepts::Space::getOutputDimension
    virtual uint getOutputDimension() const{
      return 2u;
    }
 
    inline uint dim() const;
    inline uint nelm() const;
    inline Scan* scan() const;
    inline concepts::Scan<const concepts::Quad>* interScan() const;
 
    inline uint dim();
    inline uint nelm();
    inline Scan* scan();
    inline concepts::Scan<const concepts::Quad>* interScan();
 
    virtual void adjust(const concepts::Element<Real>& elm,
      const concepts::AdaptiveAdjustP<2>& a);
 
    inline concepts::BoundaryConditions* boundary() { return bc_;}
 
    void rebuild();
    void recomputeShapefunctions();
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    concepts::Mesh2& msh_;
    concepts::BoundaryConditions* bc_;
    bool trunk_;
 
    bool rebuild_;
 
    uint dim_;
 
    uint nelm_;
 
    concepts::Joiner<hp2D::Element<Real>*, 1>* elm_;
 
    concepts::DynArray<concepts::AdaptiveControl<> > ctrl0_;
    concepts::DynArray<concepts::AdaptiveControlP<1> > ctrl1_;
    std::unordered_map<uint, concepts::AdaptiveControlP<2> > ctrl2_;
 
    std::map<uint, concepts::CellData> cellList_;
    std::map<uint, concepts::EdgeData> edgeList_;
 
    concepts::TColumnSet<Real,2> T_;
    /* Linked list of cells, created for handling subdivision
       in 4 quadrilaterials, which lie between the four children
       and the father
     */
    concepts::Joiner<const concepts::Quad*, 1>* interCells_;
    /* list of edges, created for handling subdivision
       in 4 quadrilaterials, which lie between the four children
       and the father
     */
    std::set<uint> interEdges_;
 
    concepts::DynArray<concepts::AdaptiveAdjustP<2> > adj_;
 
    std::unique_ptr<concepts::SMatrix1D> 
    S1left_t_, S1right_t_, S1left_n_, S1right_n_;
    // --> allgemein (mit hp2D) schreiben als C-Array oder Liste
    //     QuadEdgeFunctions kann hineinschreiben
    
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices2H_X_[2];
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices2H_Y_[2];
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices2V_X_[2];
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices2V_Y_[2];
 
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices2H_[2];
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices2V_[2];
    std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices4_[4];
 
    void meshAndPoly_(concepts::Quad2d& cell, concepts::Level<2>& L, int* P);
 
    void enforceBC_(concepts::Quad2d& cell);
 
    void createCellList_(const concepts::Connector& cntr,
       const concepts::CellData* father);
    void createEdgList_(const concepts::Cell2& cell);
 
    void enrichElm_(const concepts::Quad2d& cell, int* p);
 
    void minimumRule_(const concepts::Connector2& cntr,
          const concepts::Connector1& edge);
 
    void buildTColumns_(const concepts::Quad& cntr, ushort* Pmax,
      concepts::TColumn<Real>* T0 = 0);
 
    concepts::TColumn<Real>* buildEdge_(concepts::TColumn<Real>* T1, 
          const concepts::Quad& cntr,
          const uint* nn);
 
    concepts::TColumn<Real>* buildInterior_(concepts::TColumn<Real>* T1,
              const concepts::Quad& cntr,
              const uint* nn);
 
    void buildElements_(concepts::Quad2d& cell);
 
    void computePmax_(const concepts::Connector2& cntr, ushort Pmax[2]) const;
 
    void edgeOrientation_(const concepts::Connector2& cntr, const uint i,
        uint& pIndex) const;
 
    void recomputeSmatrices_(const ushort* p, const uint* nn); 
 
    void deactivate_(concepts::Edge& edg);
    void deactivate_(concepts::Vertex& vtx);
 
    void nonactiveRegion_(); 
 
    bool activeCell_(concepts::Cell& cell);
 
    void status_();
    void matlabstatus_();
  };
 
  uint Space::dim() const {
    if (rebuild_) throw conceptsException(concepts::SpaceNotBuilt());
    return dim_; 
  }
 
  uint Space::nelm() const {
    if (rebuild_) throw conceptsException(concepts::SpaceNotBuilt());
    return nelm_; 
  }
 
  Space::Scan* Space::scan() const {
    if (rebuild_) throw conceptsException(concepts::SpaceNotBuilt());
    return new concepts::PListScan<hp2D::Element<Real> >(*elm_);
  }
 
  concepts::Scan<const concepts::Quad>* Space::interScan() const {
    if (rebuild_) throw conceptsException(concepts::SpaceNotBuilt());
    return new concepts::PListScan<const concepts::Quad>(*interCells_);
  }
 
  uint Space::dim() {
    if (rebuild_) rebuild();
    return dim_; 
  }
 
  uint Space::nelm() {
    if (rebuild_) rebuild();
    return nelm_; 
  }
 
  Space::Scan* Space::scan() {
    if (rebuild_) rebuild();
    return new concepts::PListScan<hp2D::Element<Real> >(*elm_);
  }
 
  concepts::Scan<const concepts::Quad>* Space::interScan() {
    if (rebuild_) rebuild();
    return new concepts::PListScan<const concepts::Quad>(*interCells_);
  }
 
} // namespace hp2Dedge
 
#endif // hpSpace2Dedge_hh