meshImport3D.hh

Go to the documentation of this file.

 
#ifndef meshImport3D_hh
#define meshImport3D_hh
 
#include <vector>
#include <map>
#include "toolbox/hashMap.hh"
#include "mesh.hh"
#include "toolbox/array.hh"
 
namespace concepts {
  struct Index {
    Array<uint> n_;
    void sort_();
 
    Index(const uint n0);
    Index(const uint n0, const uint n1);
    Index(const uint n0, const uint n1, const uint n2);
    Index(const uint n0, const uint n1, const uint n2, const uint n3);
    Index(const Index& i) : n_(i.n_) {}
    uint size() const { return n_.size(); }
    uint operator[](const uint i) const { return n_[i]; }
    uint& operator[](const uint i) { return n_[i]; }
    bool operator<(const concepts::Index& y) const;
    bool operator==(const concepts::Index& y) const;
  };
}
 
namespace std {
  size_t hash_value(const concepts::Index& i);
 
  template<>
  struct hash<concepts::Index> {
    size_t operator()(const concepts::Index& x) const {
      return hash_value(x); }
  };
 
  struct IndexEqual {
    bool operator()(const concepts::Index& x, const concepts::Index& y) const {
      return x == y;
    }
  };
} // namespace std
 
namespace concepts {
 
  // ********************************************************** Import3dMesh **
 
  class Import3dMesh : public Mesh3 {
  public:
    Import3dMesh(const std::string coord, const std::string elms,
     const std::string boundary, const uint idxStart = 1,
     const bool leftHand = false, const uint elmtyp = 0);
    virtual ~Import3dMesh();
    virtual uint ncell() const { return cell_.size(); }
    virtual Scan3* scan() { return new S(cell_); }
 
    class NodeCell;
    class NodeTetrahedron;
    class NodeHexahedron;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    class S : public Scan<Cell3> {
    public:
      inline S(std::vector<Cell3*>& cell) :
  idx_(cell.begin()), cell_(cell) {}
      inline S(const S& scan) : idx_(scan.idx_), cell_(scan.cell_) {}
      inline bool eos() const { return idx_ == cell_.end(); }
      inline Cell3& operator++(int) { return *(*idx_++); }
      inline Scan3* clone() const { return new S(*this); }
    private:
      std::vector<Cell3*>::iterator idx_;
      std::vector<Cell3*>& cell_;
    };
    std::vector<Vertex*> vtx_;
    std::vector<Edge*> edg_;
    std::unordered_map<Index, Triangle*, std::hash<Index>,
                       std::IndexEqual> tri_;
    std::unordered_map<Index, Quad*, std::hash<Index>,
                       std::IndexEqual> quad_;
    std::vector<Cell3*> cell_;
 
    uint readInts_(const std::string& i, std::vector<int>& v) const;
 
    void clear_(std::vector<NodeCell*>& cells) const;
 
    void createEdge_(uint ix, uint iy,
         std::map<uint, std::map<uint, Edge*> >& edges,
         Attribute attr = 0, Edge** e = 0);
    Triangle* createTriangle_(const Index& I,
            std::map<uint, std::map<uint, Edge*> >& edges,
            Attribute attr = 0);
    Quad* createQuad_(const Index& I,
          std::map<uint, std::map<uint, Edge*> >& edges,
          Attribute attr = 0);
  };
 
  class Import3dMesh::NodeCell {
  protected:
    Array<uint> nodes_;
  public:
    NodeCell(const uint size) : nodes_(size) {}
    virtual ~NodeCell();
    uint operator[](const uint i) const { return nodes_[i]; }
    uint size() const { return nodes_.size(); }
 
    virtual uint nofaces() const = 0;
    virtual Index faceIndex(const uint i) = 0;
    virtual Quad** quad(const uint i) = 0;
    virtual Triangle** triangle(const uint i) = 0;
    virtual Cell3* cell(const std::vector<Real3d>& vertices) const = 0;
  };
 
  class Import3dMesh::NodeTetrahedron : public Import3dMesh::NodeCell {
  private:
    Array<Triangle*> faces_;
  public:
    NodeTetrahedron(const uint one, const uint two, const uint three,
        const uint four, const bool leftHand = false);
    virtual ~NodeTetrahedron();
    virtual uint nofaces() const { return 4; }
    virtual Index faceIndex(const uint i);
    virtual Tetrahedron3d* cell(const std::vector<Real3d>& vertices) const;
    virtual Quad** quad(const uint i) { return 0; }
    virtual Triangle** triangle(const uint i) { return &(faces_[i]); }
  };
 
  class Import3dMesh::NodeHexahedron : public Import3dMesh::NodeCell {
  private:
    Array<Quad*> faces_;
    uint elmType_;
  public:
    NodeHexahedron(const uint one, const uint two, const uint three,
       const uint four, const uint five, const uint six,
       const uint seven, const uint eight, const uint elmType = 0);
    virtual ~NodeHexahedron();
    virtual uint nofaces() const { return 6; }
    virtual Index faceIndex(const uint i);
    virtual Cell3* cell(const std::vector<Real3d>& vertices) const;
    virtual Quad** quad(const uint i) { return &(faces_[i]); }
    virtual Triangle** triangle(const uint i) { return 0; }
  };
 
} // namespace concepts
 
#endif // meshImport3D_hh