neumannTraceSpace3d.hh

Go to the documentation of this file.

 
#ifndef HP3D_NEUMANNTRACESPACE3D_HH_
#define HP3D_NEUMANNTRACESPACE3D_HH_
 
 
 
 
#include "toolbox/sequence.hh"
#include "formula/boundary.hh"
#include "formula/exceptions.hh"
#include "geometry/boundaryConditions.hh"
#include "geometry/cellConditions.hh"
#include "space/space.hh"
#include "hp2D/element.hh"
#include "hp3D.hh"
#include "hp3D/element.hh"
#include "hp3D/face.hh"
#include "hp3D/hexFunctions.hh"
 
#include "geometry/normalVector.hh"
#include "geometry/facetteTraceTypes.hh"
 
#include "neumannTraceElement3d.hh"
 
 
 
 
namespace concepts {
 
  // forward declaration
  class FaceNormalVectorRule;
}
 
namespace hp3D {
 
  using concepts::Real;
 
  // forward declaration
  class Hexahedron;
 
  // ************************************************************ NeumannTraceSpace **
 
  class NeumannTraceSpace3d : public concepts::SpaceOnCells<Real> {
  public:
    typedef concepts::Scan<hp2D::Element<Real> > Scan;
    typedef concepts::ElementAndFacette<hp3D::Element<Real> > UnderlyingElement;
 
    typedef concepts::ElementAndFacette<concepts::Quad> UnderlyingQuad;
 
 
 
//    //struct representing a quad and a underlying hexahedron's refinement level (only one hex)
//    struct quad_lvl: public concepts::OutputOperator{
//      quad_lvl(const UnderlyingQuad* quad,const concepts::Level<3> level,uint k) :level(level), quad(quad), k(k) {
//        //just same level on quads are allowed, i.e. appears for  bisection only
//        if(level.l_[0]!=level.l_[1])
//          throw conceptsException(concepts::MissingFeature("not implemented"));
//      }
//
//
//      // With this ordering  a finer Edge is followed by at most 2 coarse edge where the finer edge is a child of one of them
//      //
//   //old  // application this set is build of a endpoint nodes underlying Edges
//      // therefor each finer Edge is followed by its general father edge
//      //
//
//
//
//      // with this ordering a Set of it has the finest edges in the first places
//      // then the key sorting comes into account
//
//
//      bool operator<(edge_lvl const& right) const {
//        const concepts::Edge* edgeP = dynamic_cast<const concepts::Edge*>(edge->elm);
//        const concepts::Edge* edgeR = dynamic_cast<const concepts::Edge*>(right.edge->elm);
//
//        if(this->level.l_[0] == right.level.l_[0])
//          return edgeP->key().key()<edgeR->key().key();
//        //Note here is ">" that makes level sorting other way
//        return this->level.l_[0] > right.level.l_[0];
//
//
//       }
//
//      bool operator==(edge_lvl const& right){
//        const concepts::Edge* edgeP = dynamic_cast<const concepts::Edge*>(edge->elm);
//        const concepts::Edge* edgeR = dynamic_cast<const concepts::Edge*>(right.edge->elm);
//        return edgeP->key().key()==edgeR->key().key();
//
//      }
//
//
//      const UnderlyingQuad* quad;
//      const concepts::Level<3> level;
//
//      //the UnderlyingEdge is the k-th Edge of its underlying unique quad
//      const uint k;
//
//    protected:
//      virtual std::ostream& info(std::ostream& os) const {
//        return os << "edge_lvl("<<edge->elm->key()<<","<<level.l_[0]<<", k= "<<k<<")";
//      }
//    };
//
 
    NeumannTraceSpace3d(const concepts::SpaceOnCells<Real>& spc,
               const concepts::Set<uint> faceAttr,
               concepts::FacetteTraceType<concepts::FaceNormalVectorRule>::traceTypes
               = concepts::FacetteTraceType<concepts::FaceNormalVectorRule>::FIRST,
               const concepts::FaceNormalVectorRule&
               normalVectorRule = concepts::FaceNormalVectorRule(),
               bool emptyElm= true);
 
 
    NeumannTraceSpace3d(concepts::SpaceOnCells<Real>& spc,
        const concepts::FacetteTraceTypes<concepts::FaceNormalVectorRule>& fttypes,
        bool emptyElm= true);
 
    virtual ~NeumannTraceSpace3d();
 
    virtual uint dim() const { return dim_; }
 
    virtual uint nelm() const { return nelm_; }
 
    virtual Scan* scan() const{
      return new concepts::PListScan<hp2D::Element<Real> >(*elm_);
    }
 
//    const concepts::Sequence<UnderlyingElement>
//    uelm(const concepts::Edge edge) const
//    {
//      concepts::HashMap<hp3D::NeumannTraceElement3d<Real>*>::
//        const_iterator i = edges_.find(edge.key());
//      if (i == edges_.end())
//        return concepts::Sequence<UnderlyingElement>();
//      return i->second->uelm();
//    }
 
    //virtual void recomputeShapefunctions();
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const uint dim_;
 
    uint nelm_;
 
 
 //   concepts::Sequence<concepts::Quad3d*> coarseCells_;
//    //number of irregular builded elements
//    uint nIrrelm_;
 
    concepts::Joiner<hp2D::Element<Real>*, 1>* elm_;
 
    concepts::HashMap<hp3D::NeumannTraceElement3d<Real>* > quads_;
 
    concepts::FacetteTraceTypes<concepts::FaceNormalVectorRule> trTypes_;
 
    //flag controlling elements with no dofs in the space
    bool emptyElements_;
 
 
    // Builds the NeumanntraceElements with Informations about the Underyling Elements
    bool buildElements_(concepts::HashMap<concepts::Sequence<UnderlyingElement> >& uelm, const concepts::BoundaryConditions* bc);
 
 
    //method reconstruct all child edges belonging to a coarse edge and writes information into the coarsetochld_map
    //
    // TODO: present the algorithm here
    //
    //
    //
    //
    void reconstruct_(concepts::HashMap<concepts::Sequence<UnderlyingElement> >& irregular_uelm,
              concepts::HashMap<concepts::Sequence<UnderlyingQuad> >& nodeMap,
              concepts::HashMap<concepts::Sequence<UnderlyingQuad> >::const_iterator iterNode,
              concepts::Set<uint>& buildedEdges,
              concepts::HashMap<concepts::Sequence<UnderlyingQuad> >&  coarsetochld_map);
 
//    //Builds the NeumannTraceElements between irregular Elements, i.e. on k - irregular meshes
//    void prepareIrregularElements_(concepts::HashMap<concepts::Sequence<UnderlyingElement> >& irregular_uelm);
//
//    //actually creates the irregular ELements with the help of the mappings
//    void buildIrregularElements_(concepts::HashMap<concepts::Sequence<UnderlyingElement> >& irregular_uelm,
//                   concepts::HashMap<concepts::Sequence<UnderlyingQuad> >&  coarsetochld_map);
 
 
    Real weight_(bool first,const  concepts::Z2 dir, const uint nUelm, const concepts::Attribute attrb) const;
 
 
    //test for face-attribute is in the Set of requested quadAttributes
    bool activeQuad_(const concepts::Set<uint>& quadAttr, const concepts::Connector2& quad) {
      return quadAttr.exist(quad.attrib());
    }
 
    template<class F>
    void test_(const concepts::ElementWithCell<Real>& elm, F condition);
 
  };
 
} // namespace hp2D
 
 
 
 
 
#endif /* HP3D_NEUMANNTRACESPACE3D_HH_ */