geometry/meshImport3D.hh

Go to the documentation of this file.

/* Meshes
 * Combining cells to a mesh to represent a computational domain
 * Importing 3D meshes from Matlab files
 */

#ifndef meshImport3D_hh
#define meshImport3D_hh

#include <vector>
#include <map>

#if __ICC == 800
#  include <hash_map>
#  define __gnu_cxx std
#else
#  if __GNUC__ > 2
#    include <ext/hash_map>
#    if __GNUC__ == 3 &&__GNUC_MINOR__ < 1
#      define __gnu_cxx std
#    endif
#  else
#    include <hash_map>
#    define __gnu_cxx std
#  endif
#endif

#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 __gnu_cxx {
  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 __gnu_cxx

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_;
    __gnu_cxx::hash_map<Index, Triangle*, __gnu_cxx::hash<Index>,
      __gnu_cxx::IndexEqual> tri_;
    __gnu_cxx::hash_map<Index, Quad*, __gnu_cxx::hash<Index>,
      __gnu_cxx::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