geometry/edgeMeshes.hh

Go to the documentation of this file.

#ifndef edgeMeshes_hh
#define edgeMeshes_hh

#include "toolbox/array.hh"
#include "toolbox/sequence.hh"
#include "cell1D.hh"
#include "elementMaps.hh"
#include "mesh.hh"
#include "topology.hh"

namespace concepts {

  // ************************************************************** EdgeMesh **

  class EdgeMesh : public Mesh1 {
  public:
    EdgeMesh(const uint n, bool closed,
             const Sequence<MappingEdge2d*>& maps,
             Attribute attrib = Attribute());

    EdgeMesh(const MappingEdge2d* map, Attribute attrib = Attribute());

    virtual ~EdgeMesh();

    inline uint   ncell() const { return ncell_; }
    inline Scan1* scan()        { return new S(&cell_); }

    inline const Sequence<Edge2d*>& cells() const { return cell_; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    
    const uint n_;
    uint ncell_;

    Array<MappingEdge2d*> edges_;

    Sequence<Edge2d*> cell_;
  private:
    Array<Vertex*> vtx_;
    Array<Edge*>   edg_;

    class S : public Scan<Cell1> {
      uint idx_;
      Sequence<Edge2d*>* cell_;
    public:
      inline S(Sequence<Edge2d*>* cell) : idx_(0), cell_(cell) {}
      inline S(const S &scan) : idx_(scan.idx_), cell_(scan.cell_) {}

      inline bool eos() const { return idx_ == cell_->size(); }
      inline Cell1& operator++(int) { return *(*cell_)[idx_++]; }

      inline Scan1* clone() const { return new S(*this); }
    };

  };

  // ********************************************************* CircleBoundary **

  class CircleBoundary : public Mesh1, public InnerOuterBoundary2d {
  public:
    CircleBoundary(const Real2d center, const uint n, const Real r, 
                   const uint attrib = 0, const Real phi0 = 0);
    virtual ~CircleBoundary();

    inline uint ncell() const { return ncell_; }
    inline Scan1* scan() { return new S(&this->outerBoundary_); }

    const Sequence<Edge2d*>& cells() const { return this->outerBoundary_; }

    virtual std::ostream& info(std::ostream& os) const;
  private:
    class S : public Scan<Cell1> {
      uint idx_;
      Sequence<Edge2d*>* cell_;
    public:
      inline S(Sequence<Edge2d*>* cell) : idx_(0), 
                                          cell_(cell) {}
      inline S(const S &scan) : idx_(scan.idx_),
                                cell_(scan.cell_) {}
      
      inline bool eos() const { return idx_ == cell_->size(); }
      inline Cell1& operator++(int) { return *(*cell_)[idx_++]; }

      inline Scan1* clone() const { return new S(*this); }
    };

    uint ncell_;

    Array<Vertex*> vtx_;
    Array<Edge*> edg_;
  };

} // namespace concepts

#endif // edgeMeshes_hh