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(),
             Sequence<Attribute> vattrib = Sequence<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 Edge2d& 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_;
  };
 
  // ********************************************** StraightPeriodicBoundary **
 
  class StraightPeriodicBoundary : public Mesh1, public InnerOuterBoundary2d {
  public:
    StraightPeriodicBoundary(const Real2d first, const Real2d last,
                             const uint n, const uint attrib = 0);
    virtual ~StraightPeriodicBoundary();
 
    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