geometry/square.hh

Go to the documentation of this file.

/* square made out of one or two hexahedron
 */

#ifndef square_hh
#define square_hh

#include "basics/typedefs.hh"
#include "mesh.hh"
#include "topology.hh"
#include "cell2D.hh"

namespace concepts {

  // ****************************************************************** Square **

  class Square : public Mesh2 {
    static const uint ncell_ = 1;
  public:
    Square(const Real sizex = 1.0, const Real sizey = 1.0,
           const uint attrib = 0);
    Square(const Real x0, const Real y0, const Real x1, const Real y1, 
           const Real x2, const Real y2, const Real x3, const Real y3,
           const uint attrib = 0);
    Square(const Real sizex, const Real sizey,
           const Array<uint>& attrib,
           const Array<uint>* vattrib = 0);
    Square(const Real x0, const Real y0, const Real x1, const Real y1, 
           const Real x2, const Real y2, const Real x3, const Real y3,
           const Array<uint>& attrib,
           const Array<uint>* vattrib = 0);
    virtual ~Square();

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

    virtual std::ostream& info(std::ostream& os) const;
  private:
    class S : public Scan<Cell2> {
      uint idx_;
      Quad2d *(&cell_)[ncell_];
    public:
      inline S(Quad2d *(&cell)[ncell_]) : idx_(0), cell_(cell) {}
      inline S(const S &scan) : idx_(scan.idx_), cell_(scan.cell_) {}

      inline bool eos() const { return idx_ == ncell_; }
      inline Cell2& operator++(int) { return *cell_[idx_++]; }

      inline Scan2* clone() const { return new S(*this); }
    };
    void construct_(const Array<Real2d>& coord,
                    const Array<uint>& attrib,
                    const Array<uint>* vattrib = 0);

    Vertex* vtx_[4];
    Edge* edg_[4];
    Quad* quad_[ncell_];

    Quad2d* cell_[ncell_];
  };

  // ***************************************************************** Square2 **

  class Square2 : public Mesh2 {
    static const uint ncell_ = 2;
  public:
    Square2();
    Square2(Array<uint> attrib);
    virtual ~Square2();

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

    virtual std::ostream& info(std::ostream& os) const;
  private:
    class S : public Scan<Cell2> {
      uint idx_;
      Quad2d *(&cell_)[ncell_];
    public:
      inline S(Quad2d *(&cell)[ncell_]) : idx_(0), cell_(cell) {}
      inline S(const S &scan) : idx_(scan.idx_), cell_(scan.cell_) {}

      inline bool eos() const { return idx_ == ncell_; }
      inline Cell2& operator++(int) { return *cell_[idx_++]; }

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

    void construct_(const Array<uint>& attrib);


    Vertex* vtx_[6];
    Edge* edg_[7];
    Quad* quad_[ncell_];

    Quad2d* cell_[ncell_];
  };

} // namespace concepts

#endif // square_hh