mutableMesh.hh

Go to the documentation of this file.

 
#ifndef mutableMesh_hh
#define mutableMesh_hh
 
#include "toolbox/multiArray.hh"
#include "toolbox/sequence.hh"
#include "toolbox/set.hh"
#include "mesh.hh"
 
namespace concepts {
 
  // ******************************************************* MutableMeshBase **
 
  class MutableMeshBase {
  public:
    MutableMeshBase();
    virtual ~MutableMeshBase();
 
    virtual void addCell(Cell* cell, bool holding = true) = 0;
 
    Edge* ownEdge(Vertex* vtx1, Vertex* vtx2);
 
    const Sequence<Connector0*>& ownConnectors0() const {
      return ownConnectors0_; }
    const Sequence<Connector1*>& ownConnectors1() const {
      return ownConnectors1_; }
    const Sequence<Connector2*>& ownConnectors2() const {
      return ownConnectors2_; }
    const Sequence<Connector3*>& ownConnectors3() const {
      return ownConnectors3_; }
  protected:
    Sequence<const Cell*>       ownCells_;
    Sequence<Connector0*> ownConnectors0_;
    Sequence<Connector1*> ownConnectors1_;
    Sequence<Connector2*> ownConnectors2_;
    Sequence<Connector3*> ownConnectors3_;
    MultiArray<2, Edge*> mapEdges_;
 
    void addCell_(Cell* cell, bool holding = true);
 
    void replaceCell_(Cell* cell, bool holding = true);
  };
 
  // ********************************************************** MutableMesh1 **
 
  class MutableMesh1 : public Mesh1, public MutableMeshBase {
  public:
    MutableMesh1() : ncell_(0) {}
    virtual ~MutableMesh1();
    inline uint ncell() const { return ncell_; }
    inline Scan1* scan() { return new PStlVectorScan<Cell1>(cells_); }
 
    virtual void addCell(Cell* cell, bool holding = true);
    
    void replaceCell(Cell1* cell, bool holding = true);
    
    inline const Sequence<Cell1*>& cells() const { return cells_; }
    
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    
  private:
    uint ncell_;
    Sequence<Cell1*> cells_;
  };
 
  // ********************************************************* buildEdgeMesh **
  
  void buildEdgeMesh(Scan2* sc, const concepts::Set<uint> attrib,
                     MutableMeshBase& emsh);
 
  // ********************************************************** MutableMesh2 **
 
  class MutableMesh2 : public Mesh2, public MutableMeshBase {
  public:
    MutableMesh2() : ncell_(0) {}
    virtual ~MutableMesh2();
    inline uint ncell() const { return ncell_; }
    inline Scan2* scan() { return new PStlVectorScan<Cell2>(cells_); }
 
    virtual void addCell(Cell* cell, bool holding = true);
 
    void replaceCell(Cell2* cell, bool holding = true);
 
    Cell2* lastCell() const { 
      if (ncell_)
        return cells_[ncell_-1];
      return 0;
    }
 
    void addMesh(Mesh2& msh);
 
    void connectOppositeEdges(const Edge2d* edge1, const Edge2d* edge2,
                              const Attribute attrib = Attribute(),
                              const Quad2dSubdivision* strategy = 0);
 
    void connectOppositeEdges(const Sequence<Edge2d*> edges1, 
                              const Sequence<Edge2d*> edges2,
                              const Attribute attrib = Attribute(),
                              const Quad2dSubdivision* strategy = 0);
 
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    uint ncell_;
    Sequence<Cell2*> cells_;
  };
 
  // ******************************************************* ConnectTwoMeshes2 **
 
  class ConnectTwoMeshes : public MutableMesh2, public InnerOuterBoundary2d {
  public:
    ConnectTwoMeshes(Mesh2withBoundary& mesh1, const Sequence<uint> edges1,
                     Mesh2withBoundary& mesh2, const Sequence<uint> edges2,
                     const Attribute attrib = Attribute());
    virtual ~ConnectTwoMeshes() {}
  };
 
} // namespace concepts
 
#endif // mutableMesh_hh