space.hh

Go to the documentation of this file.

 
#ifndef linDG2Dspace_hh
#define linDG2Dspace_hh
#include "toolbox/hashMap.hh"
#include "space/space.hh"
#include "toolbox/scannerConnectors.hh"
#include "graphics/spaceTraits.hh"
 
#include "triangle.hh"
 
namespace concepts {
  // forward declarations
  class Mesh2;
  class BoundaryConditions;
}  
 
namespace linDG2D {
 
  using concepts::Real;
 
  // ***************************************************************** Space **
 
  class Space : public concepts::Space<Real> {
  public:
    typedef void (*SMap)(const concepts::TColumn<Real>&,
                         concepts::TColumn<Real>&);
    typedef std::unordered_map<uint, Triangle*> Map;
    Space() : dim_(0), nelm_(0) {}
    virtual ~Space();
    virtual Scanner* scan() const { return new S(elm_); }
    virtual uint dim() const { return dim_; }
    virtual uint nelm() const { return nelm_; }
    virtual const Triangle& elm(const concepts::Triangle2d* cell) const {
      conceptsAssert(cell, concepts::Assertion());
      const Map::const_iterator i = elm_.find(cell->connector().key());
      conceptsAssert(!(i == elm_.end()), concepts::Assertion());
      return *(i->second);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    virtual Triangle* newElm_(const concepts::Triangle2d& cell,
                              uint idx[]) const = 0;
    virtual uint nDoF_() const = 0;
    virtual void constructor_(concepts::Mesh2& mesh);
  private:
    class S : public Scanner {
    public:
      inline S(const Map& elm) : idx_(elm.begin()), elm_(elm) {}
      inline S(const S& scan) : idx_(scan.idx_), elm_(scan.elm_) {}
      inline bool eos() const { return idx_ == elm_.end(); }
      inline Triangle& operator++(int) { 
        return const_cast<Triangle&>(*((*idx_++).second));
      }
      inline S* clone() const { return new S(*this); }
    private:
      Map::const_iterator idx_;
      const Map& elm_;
    };
    uint dim_;
    uint nelm_;
    Map elm_;
  };
 
  // ************************************************************** SpaceP1 **
 
  class SpaceP1 : public Space {
  public:
    typedef TriangleP1 Element;
    SpaceP1(concepts::Mesh2& msh) { constructor_(msh); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    virtual Triangle* newElm_(const concepts::Triangle2d& cell,
                              uint idx[]) const {
      return new TriangleP1(cell, idx);
    }
    virtual uint nDoF_() const { return 3; }
  };
 
  // ************************************************************** SpaceP0 **
 
  class SpaceP0 : public Space {
  public:
    typedef TriangleP0 Element;
    SpaceP0(concepts::Mesh2& msh) { constructor_(msh); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    virtual Triangle* newElm_(const concepts::Triangle2d& cell,
                              uint idx[]) const {
      return new TriangleP0(cell, idx);
    }
    virtual uint nDoF_() const { return 1; }
  };
 
} // namespace linDG2D
 
// *********************************************** Space Traits for Graphics **
 
namespace graphics {
  template<>
  struct spaceTraits<linDG2D::Space> {
    static inline uint dim() { return 2; }
    static inline bool positionConnection() { return false; }
    static inline bool boundaryElements() { return false; }
  };
  template<>
  struct spaceTraits<linDG2D::SpaceP1> {
    static inline uint dim() { return 2; }
    static inline bool positionConnection() { return false; }
    static inline bool boundaryElements() { return false; }
  };
  template<>
  struct spaceTraits<linDG2D::SpaceP0> {
    static inline uint dim() { return 2; }
    static inline bool positionConnection() { return false; }
    static inline bool boundaryElements() { return false; }
  };
} // namespace graphics
 
#endif // linDG2Dspace_hh