space.hh

Go to the documentation of this file.

 
#ifndef hpSpace3D_hh
#define hpSpace3D_hh
 
#include <memory>
#include <map>
#include <cstring>
#include "basics/exceptions.hh"
#include "basics/typedefs.hh"
#include "basics/level.hh"
#include "toolbox/hashMap.hh"
#include "space/space.hh"
#include "space/hpMethod.hh"
#include "space/smatrix.hh"
#include "geometry/continuityData.hh"
#include "geometry/cell3D.hh"
#include "geometry/mesh.hh"
#include "geometry/boundaryConditions.hh"
#include "geometry/cellConditions.hh"
#include "toolbox/scannerConnectors.hh"
#include "element.hh"
 
namespace concepts {
 
  // forward declaration
  class InOutParameters;
 
  // ****************************************************************** Scan **
 
  template<>
  class Scan<hp3D::Element<Real> > :
    public concepts::Scan<concepts::ElementWithCell<Real> > {
  public:  
    hp3D::Element<Real>& operator++(int) = 0;
  };
 
} // namespace concepts
 
namespace hp3D {
  using concepts::Real;
 
  // forward declarations
  class Hexahedron;
  class BuildDofsBase;
  class TraceSpace;
 
  // ***************************************************************** Space **
 
  class Space :
    public concepts::SpaceOnCells<Real>,
    public concepts::AdaptiveSpace<Real, concepts::AdaptiveAdjustP<3> > {
    friend class BuildDofsBase;
  public:
    typedef concepts::Scan<hp3D::Element<Real> > Scan;
    typedef hp3D::TraceSpace TraceSpaceT;
 
    Space(concepts::Mesh3& msh, uint l, uint p,
    concepts::BoundaryConditions* bc = 0, concepts::CellConditions* cc = 0);
    Space(const Space& spc);
    virtual ~Space();
    
    inline virtual uint dim() const;
    inline virtual uint nelm() const;
    inline virtual Scan* scan() const;
    inline virtual const  concepts::BoundaryConditions* bc() const;
 
    inline uint dim();
    inline uint nelm();
    inline Scan* scan();
    inline const concepts::BoundaryConditions* bc();
 
 
    inline void getPmax(const concepts::Hexahedron& cntr,
            ushort Pmax[3]) const{
      getPmax_(cntr,Pmax);
    }
 
 
    void setDim(uint dim);
 
    virtual void adjust(const concepts::Element<Real>& elm,
      const concepts::AdaptiveAdjustP<3>& a);
 
    Space rebuild();
 
    const std::unique_ptr<concepts::SMatrixBase<Real> >*
    getSmatrices(const concepts::Hex3dSubdivision* subdiv) const;
 
    void recomputeSmatrices(const Hexahedron* elm) const;
 
       void recomputeShapefunctions();
 
    static void setTimings(concepts::InOutParameters* timings);
    static bool timings();
 
    void buildVertexDofs(const BuildDofsBase& b);
    void buildEdgeDofs(const BuildDofsBase& b);
    void buildFaceDofs(const BuildDofsBase& b);
    void buildInnerDofs(const BuildDofsBase& b);
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    concepts::Mesh3& msh_;
    concepts::BoundaryConditions* bc_;
    concepts::CellConditions* cc_;
    bool rebuild_;
 
    uint dim_;
    uint nelm_;
    concepts::Joiner<Element<Real>*, 1>* elm_;
    concepts::Joiner<Element<Real>*, 1>* endElm_;
    std::unordered_map<uint, concepts::AdaptiveControl<> > ctrl0_;
    std::unique_ptr<std::unordered_map<uint,
              concepts::AdaptiveControlP<1> > > ctrl1_;
    std::unique_ptr<std::unordered_map<uint,
              concepts::AdaptiveControlP<2> > > ctrl2_;
    std::unordered_map<uint, concepts::AdaptiveControlP<3> > ctrl3_;
    std::unordered_map<uint, concepts::AdaptiveControlP<3> > pMax_;
 
    std::map<uint, concepts::CellData> cellList_;
    std::map<uint, concepts::FaceData> faceList_;
    std::map<uint, concepts::EdgeData> edgeList_;
    std::map<uint, concepts::VertexData> vertexList_;
 
    std::unordered_map<uint, concepts::AdaptiveAdjustP<3> > adj_;
 
    mutable std::unique_ptr<concepts::SMatrix1D> S1left_, S1right_;
    mutable std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices8_[8];
    mutable std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices4x_[4],
      Smatrices4y_[4], Smatrices4z_[4];
    mutable std::unique_ptr<concepts::SMatrixBase<Real> > Smatrices2x_[2],
      Smatrices2y_[2], Smatrices2z_[2];
 
    static concepts::InOutParameters* timings_;
    static uint timeCntr_;
 
    std::unique_ptr<BuildDofsBase> buildVertexDofs_;
    std::unique_ptr<BuildDofsBase> buildEdgeDofs_;
    std::unique_ptr<BuildDofsBase> buildFaceDofs_;
    std::unique_ptr<BuildDofsBase> buildInnerDofs_;
 
    void meshAndPoly_(concepts::Hexahedron3d& cell,
          concepts::Level<3>& L, int* P);
 
    void enforceBC_(concepts::Hexahedron3d& cell);
 
    void enforceCC_(concepts::Hexahedron3d& cell);
    
    void createCellList_(const concepts::Connector& cntr,
       const concepts::CellData* father);
    void createEdgFaceList_(const concepts::Cell3& cell);
    void createVtxEdgList_(const concepts::Cell3& cell);
 
    void enrichElm_(const concepts::Hexahedron3d& cell, int* p);
 
    void buildElements_(concepts::Hexahedron3d& cell,
      ushort* Pmax,
      concepts::TColumn<Real>* T0 = 0);
 
    void getPmax_(const concepts::Hexahedron& cntr,
          ushort Pmax[3]) const;
    
    void computePmax_(const concepts::Hexahedron& cntr,
          ushort Pmax[3]) const;
 
    void deactivate_(const concepts::Connector2& face);
    void deactivate_(const concepts::Connector1& edg);
    void deactivate_(const concepts::Connector0& vtx);
    void doCorrectRefinement_(concepts::Hexahedron3d& cell,
            concepts::Level<3>& L) const;
  };
 
  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_);
  }
 
  const concepts::BoundaryConditions* Space::bc() const{
    if (rebuild_) throw conceptsException(concepts::SpaceNotBuilt());
    return bc_;
  }
 
  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_);
  }
 
  const concepts::BoundaryConditions* Space::bc(){
    if (rebuild_) rebuild();
    return bc_;
  }
 
} // namespace hp3d
 
#include "buildDofsBase.hh"
 
#endif // hpElement3d_h