patches.hh

Go to the documentation of this file.

 
#ifndef patches_hh
#define patches_hh
 
#include "space.hh"
#include "hp2D.hh"
#include "geometry.hh"
#include "toolbox.hh"
 
namespace geometry {
 
using namespace concepts;
 
 
// a pair of a Quadkey  and a local dof of the corresponding patch node
struct quad_loc: public OutputOperator{
  uint key;
  //i is the local dof i = 0,1 , p[0]+1, p[0]+2 of nodal bases on the vtx n of the Patch corresponding to the quad
  uint i;
  //concepts::Z4 i;
 
  //this can be a uint also
  quad_loc(uint qkey, uint ldof){
    key = qkey;
    i = ldof;
  }
 
  bool operator<(quad_loc const& right) const
     {
         return this->key < right.key;
     }
 
  //if Z4  use operator int()
   virtual std::ostream& info(std::ostream& os) const{
     return os<< concepts::typeOf(*this) <<"("<<key<<","<<i<<")";
   }
 
};
 
struct edge_dof: public OutputOperator{
  uint eKey;
  //local dof of corresponding node to this edge
  concepts::Z2 i;
 
//  edge_dof(){
//    eKey=0;
//    i=0;
//  }
 
  edge_dof(uint edgeKey, concepts::Z2 loc){
    eKey = edgeKey;
    i = loc;
  }
 
//  edge_dof& operator=(const edge_dof& rval){
//    eKey = rval.eKey;
//    i = rval.i;
//    return *this;
//  }
 
   virtual std::ostream& info(std::ostream& os) const{
     return os<< concepts::typeOf(*this)<< "("<<eKey<<","<<i.operator int()<<")";
   }
};
 
 
//################################################  ElementPatch  #############################
 
class ElementPatch: public OutputOperator {
public:
 
 
 
  //make sure new PatchTypes, are involved in the methods
  enum PatchType{
    INNER,
    NEUMANN_NEUMANN,
    DIRICHLET_NEUMANN,
    NEUMANN_DIRICHLET,
    DIRICHLET_DIRICHLET,
    NOT_FEATURED_YET
  };
 
  typedef Sequence<quad_loc>::iterator iterator;
  typedef Sequence<quad_loc>::const_iterator const_iterator;
 
 
  ElementPatch() {
    lEdgeType_(Boundary::FREE);
    rEdgeType_(Boundary::FREE);
  }
 
  ElementPatch(const ElementPatch& elmPatch) {
    for (Sequence<quad_loc>::const_iterator iter = elmPatch.begin(); iter
        != elmPatch.end(); ++iter)
      elmP_.push_back(*iter);
    rEdgeType_ = elmPatch.rEdgeType_;
    lEdgeType_ = elmPatch.lEdgeType_;
  }
 
  virtual ~ElementPatch() {};
 
 
 
  bool getPos(uint quadKey, uint& pos) const;
 
  enum PatchType patchType() const;
 
  Boundary getBoundaryEdgeType(uint i) const;
 
 
  //uint <-> Z4
  void push_back(uint elmKey, uint i);
 
  inline iterator begin() {
    return iterator(elmP_.begin());
  }
 
  inline const_iterator begin() const {
    return const_iterator(elmP_.begin());
  }
 
  inline iterator end() {
    return iterator(elmP_.end());
  }
 
  inline const_iterator end() const {
    return const_iterator(elmP_.end());
  }
 
  /*
   * Method to add the (unique) key at the first position in the ElementPatch.
   * If Key is already in the Patch added before it will be set to the first position.
   * This has an application when sorting the Patch later cause no more Info will be needed.
   *
   * @param elmKey Key of the Element.
   */
  //Z4 as uint
  void insert1st(uint elmKey, uint i);
 
 
  /*
   * @returns Returns the amount of Elements in the Patch.
   */
  inline uint size() const {
    return elmP_.size();
  }
 
  inline bool type() const {
    return lEdgeType_.type() && rEdgeType_.type();
  }
 
  /*
   * Method updates the left Edge corresponding to the Vertex that introduces
   * the Patch elmP_. Make sure you know the orientation of the edge (see e.g.
   * rho function in topology.hh) to chose right Edge
   *
   * n = local number of vtx corresponding to the node
   */
  inline void typeUpdateL(concepts::Boundary type) {
    lEdgeType_ = type;
  }
 
  inline void typeUpdateR(concepts::Boundary type) {
    rEdgeType_ = type;
  }
 
  //TODO: GO private?
  bool exist(uint elmKey);
 
  inline quad_loc& operator[](uint pos)  {
    assert(pos < elmP_.size());
    return elmP_[pos];
  }
 
  inline quad_loc operator[](uint pos) const {
    assert(pos < elmP_.size());
    return elmP_[pos];
  }
 
protected:
 
  std::ostream& info(std::ostream& os) const;
 
private:
  //A sequence of element keys, in general not sorted.
  Sequence<quad_loc> elmP_;
 
 
  //  ----leftedge----o----rightegde---- ,  clockwise
  // for Boundary vertices, representing the left egde type to the boundary Node
  concepts::Boundary lEdgeType_;
  // for Boundary vertices, representing the right egde type to the boundary Node
  concepts::Boundary rEdgeType_;
};
 
 
//################################################  EdgePatch  #############################
 
class EdgePatch:  public OutputOperator{
public:
 
 
 
  typedef Sequence<edge_dof>::iterator iterator;
  typedef Sequence<edge_dof>::const_iterator const_iterator;
 
  EdgePatch() {}
 
  virtual ~EdgePatch(){}
 
  void push_back(uint edgeKey, concepts::Z2 i);
 
  bool exist(uint edgeNo);
 
 
  void insert1st(uint edgeKey, concepts::Z2 i);
 
 
  //iterator section
  inline iterator begin() {
    return iterator(edgeP_.begin());
  }
 
  inline const_iterator begin() const {
      return const_iterator(edgeP_.begin());
    }
 
  inline iterator end() {
    return iterator(edgeP_.end());
  }
 
  inline const_iterator end() const {
      return const_iterator(edgeP_.end());
  }
 
 
  inline edge_dof operator[](uint noE) const {
    assert( noE < edgeP_.size());
    return edgeP_[noE];
  }
 
protected:
  //outputoperator
  std::ostream& info(std::ostream& os) const;
 
private:
  //A sequence of keys, general unsorted.
  Sequence<edge_dof> edgeP_;
};//class EdgePatch;
 
 
class VtxToElmSupportMap: public OutputOperator {
public:
 
  typedef HashMap<ElementPatch>::iterator iterator;
  typedef HashMap<ElementPatch>::const_iterator const_iterator;
 
  VtxToElmSupportMap() {
  }
 
  VtxToElmSupportMap(VtxToElmSupportMap& velmMap) {
    HashMap<ElementPatch>::const_iterator iter = velmMap.begin();
    for (; iter != velmMap.end(); ++iter)
      map_[iter->first] = ElementPatch(iter->second);
  }
 
  virtual ~VtxToElmSupportMap() {
  }
 
  // ##### Iterator section
 
  inline iterator begin() {
    return iterator(map_.begin());
  }
 
  inline const_iterator begin() const {
    return const_iterator(map_.begin());
  }
 
  inline iterator end() {
    return iterator(map_.end());
  }
 
  inline const_iterator end() const {
    return const_iterator(map_.end());
  }
 
  inline size_t size() const{
    return map_.size();
  }
 
  ElementPatch& operator[](uint noVtx) {
    return map_[noVtx];
  }
 
 
  inline const ElementPatch&  operator()(uint noVtx) const{
    assert(map_.find(noVtx)!=map_.end());
    return map_.find(noVtx)->second;
  }
 
  std::ostream& info(std::ostream& os) const;
 
private:
  HashMap<ElementPatch> map_;
 
};
class VtxToEdgeSupportMap: public OutputOperator {
public:
 
  typedef HashMap<EdgePatch>::iterator iterator;
  typedef HashMap<EdgePatch>::const_iterator const_iterator;
 
  VtxToEdgeSupportMap() {
  }
  virtual ~VtxToEdgeSupportMap() {
  }
 
  //#################         Iterator section
  inline iterator begin() {
    return iterator(map_.begin());
  }
 
  inline const_iterator begin() const {
    return const_iterator(map_.begin());
  }
 
  inline iterator end() {
    return iterator(map_.end());
  }
 
  inline const_iterator end() const {
    return const_iterator(map_.end());
  }
 
  inline EdgePatch& operator[](uint noVtx) {
    return map_[noVtx];
  }
 
 
  inline const EdgePatch&  operator()(uint noVtx) const{
        assert(map_.find(noVtx)!=map_.end());
      return map_.find(noVtx)->second;
  }
 
protected:
  std::ostream& info(std::ostream& os) const;
private:
  HashMap<EdgePatch> map_;
};
 
class VtxToPatchMaps: public OutputOperator {
 
public:
  template<class F>
  VtxToPatchMaps(const Space<F>& spc, BoundaryConditions& bc);
 
 
  virtual ~VtxToPatchMaps() {};
 
 
  inline const VtxToEdgeSupportMap& vtxToEdgeSupportMap() const  {
    return edgemap_;
  }
 
 
  inline const VtxToElmSupportMap& vtxToElmSupportMap() const {
    return elmmap_;
  }
 
 
  const concepts::BoundaryConditions& boundaryInfo() const{
    return bc_;
  }
 
  bool appearingSizes(concepts::Set<uint>& set,const enum ElementPatch::PatchType type) const;
 
  protected:
  //output of the elm -and edgemaps
  std::ostream& info(std::ostream& os) const;
 
  private:
  //map holding the edge-Patch information
  VtxToEdgeSupportMap edgemap_;
  //map holding the elm-Patch information
  VtxToElmSupportMap elmmap_;
  //reference to the boundary conditions
  concepts::BoundaryConditions& bc_;
 
  //maps from E to Edgenodes to Quads_loc
  //map from edge to its underlying quad(s), needed for sorting, and finding neighboured quad
  HashMap<Set<uint> > EtoQuadmap_;
 
  //Sets holding all appearing Patchsizes that exist in the given spaceMesh. Set is empty if the kind of Patch does not exist.
  concepts::Set<uint> innerPatchsizes_;
  concepts::Set<uint> nnPatchsizes_;
  concepts::Set<uint> ndPatchsizes_;
  concepts::Set<uint> dnPatchsizes_;
  concepts::Set<uint> ddPatchsizes_;
 
  // Method collect necessary informations to sort patches later, i.e. it fills the EtoQuadmap and the rEdge-mappings.
  // Furthermore ElmPatches get filled with its belonging Elm-Keys, but unsorted. Then the correct Patchsize is known.
  void addElementInformation_(const hp2D::Quad<Real>* elmH, HashMap<Set<uint> >& EtoQuadmap, HashMap<HashMap<uint> >& rEdge);
 
  // Method sorts the Element-Patches (with rEdge, and EtoElmMap) with overwriting and collect the Patch-sizes.
  void completeElmPatches_(const HashMap<Set<uint> >& EtoQuadmap,const HashMap<HashMap<uint> >& rEdge);
 
  // Method sorts the Edgepatches by overwriting.
  void completeEdgePatches_(const HashMap<HashMap<uint> >& rEdge);
 
};
 
}//namespace concepts
#endif