hp2D/space.hh

Go to the documentation of this file.

/* space class for 2D hp FEM
 */

#ifndef hpSpace2D_hh
#define hpSpace2D_hh

#include <memory>
#include <cstring>
#include <set>
#include "basics/exceptions.hh"
#include "basics/typedefs.hh"
#include "toolbox/scannerConnectors.hh"
#include "toolbox/hashMap.hh"
#include "geometry/continuityData.hh"
#include "geometry/cell2D.hh"
#include "geometry/mesh.hh"
#include "geometry/boundaryConditions.hh"
#include "space/space.hh"
#include "space/hpMethod.hh"
#include "element.hh"

namespace concepts {

  // forward declarations
  template<class F>
  class SMatrixBase;

  class SMatrix1D;

//   // ****************************************************************** Scan **

//   template<>
//   class Scan<hp2D::Element<Real> > :
//     public concepts::Scan<concepts::Element<Real> > 
//   {
//   public:  
//     hp2D::Element<Real>& operator++(int) = 0;
//   };

} // namespace concepts

namespace hp2D {
  using concepts::Real;

  // forward declarations
  template<class F>
  class Quad;

  class BuildDofsBase;

  // ****************************************************** IndexNotExisting **

  class NotConnectedIndex : public concepts::ExceptionBase {};

  // ***************************************************************** Space **

  class Space :
    public concepts::SpaceOnCells<Real>,
    public concepts::AdaptiveSpace<Real, concepts::AdaptiveAdjustP<2> > 
  {
  public:
    friend class BuildDofsBase;

    typedef concepts::Scan<hp2D::Element<Real> > Scan;

    Space(concepts::Mesh2& msh, uint l, uint p,
          concepts::BoundaryConditions* bc = 0);
    Space(const Space& spc);
    virtual ~Space();

    inline virtual uint dim() const;
    inline virtual uint nelm() const;
    inline virtual Scan* scan() const;
    inline Scan* constScan() const;

    inline uint dim();
    inline uint nelm();
    inline Scan* scan();

    virtual void adjust(const concepts::Element<Real>& elm,
                        const concepts::AdaptiveAdjustP<2>& a);

    Space rebuild();

    void buildVertexDofs(const BuildDofsBase& b);

    void buildEdgeDofs(const BuildDofsBase& b);

    void buildInnerDofs(const BuildDofsBase& b);

    uint connectedIdx(const concepts::Attribute& a) const;

    void recomputeShapefunctions();
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    concepts::Mesh2& msh_;
    concepts::BoundaryConditions* bc_;

    bool rebuild_;

    uint dim_;

    uint nelm_;

    concepts::Joiner<Element<Real>*, 1>* elm_;

    __gnu_cxx::hash_map<uint, concepts::AdaptiveControl<> > ctrl0_;
    std::auto_ptr<__gnu_cxx::hash_map< uint, concepts::AdaptiveControlP<1> > > ctrl1_;
    __gnu_cxx::hash_map<uint, concepts::AdaptiveControlP<2> > ctrl2_;

    __gnu_cxx::hash_map<uint, concepts::AdaptiveControl<> > ctrlc0_;

    __gnu_cxx::hash_map<uint, const concepts::Attribute*> vtxConnect_;

    std::map<uint, concepts::CellData> cellList_;
    std::map<uint, concepts::EdgeData> edgeList_;
    std::map<uint, concepts::VertexData> vertexList_;

    /* Linked list of ghost cells, created for handling subdivision
       in 4 quadrilaterials
       */
    //     concepts::Joiner<concepts::Quad*, 1>* ghostCells_;

    __gnu_cxx::hash_map<uint, concepts::AdaptiveAdjustP<2> > adj_;

    std::auto_ptr<concepts::SMatrix1D> S1left_, S1right_;
    std::auto_ptr<concepts::SMatrixBase<Real> > Smatrices2H_[2];
    std::auto_ptr<concepts::SMatrixBase<Real> > Smatrices2V_[2];
    std::auto_ptr<concepts::SMatrixBase<Real> > Smatrices4_[4];

    std::auto_ptr<BuildDofsBase> buildVertexDofs_;
    std::auto_ptr<BuildDofsBase> buildEdgeDofs_;
    std::auto_ptr<BuildDofsBase> buildInnerDofs_;

  private:
    void meshAndPoly_(concepts::Quad2d& cell, concepts::Level<2>& L, int* P);

    void enforceBC_(const concepts::Connector2& cell);

    void createCellList_(const concepts::Connector& cntr,
        const concepts::CellData* father);
    void createVtxEdgList_(const concepts::Connector2& cell);

    void enrichElm_(const concepts::Quad2d& cell, int* p);

    void minimumRule_(const concepts::Connector2& cntr,
        const concepts::Connector1& edge);

    void buildElements_(concepts::Quad2d& cell, ushort* Pmax,
        concepts::TColumn<Real>* T0 = 0);

    void buildEmptyElements_(concepts::Quad2d& cell);

    void computePmax_(const concepts::Connector2& cntr,
        ushort Pmax[2]) const;

    void recomputeSmatrices_(const Quad<Real>& elm);

    void deactivate_(const concepts::Edge& edg);
    void deactivate_(const concepts::Vertex& vtx);

    bool activeCell_(concepts::Cell& cell);
    void status_();
    void matlabstatus_();


    Space(const Space& spc, uint i);
  };

  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<Element<Real> >(*elm_);
  }

  Space::Scan* Space::constScan() const {
    return new concepts::PListScan<Element<Real> >(*elm_);
  }

  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<Element<Real> >(*elm_);
  }

} // namespace hp2D

#include "buildDofsBase.hh"

#endif // hpSpace2D_h