mesh/Mesh.hpp

#ifndef __MESH_HPP__
#define __MESH_HPP__

#include "tools/Tools.hpp"

#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <string>
#include <sstream>

#include <boost/array.hpp>

namespace DAPTA { // Define namespace DAPTA


template <typename Traits = Tetra4MeshTraits>
class Mesh {
   public:
      // TYPE DEFINITIONS
      typedef typename Traits::VertexType                              VertexType;
      typedef typename Traits::VertexHandle                            VertexHandle;
      
      typedef typename Traits::ElementType                             ElementType;
      typedef typename Traits::ElementHandle                           ElementHandle;
      
      typedef typename Traits::CohElementType                          CohElementType;
      typedef typename Traits::CohElementHandle                        CohElementHandle;
      
      typedef typename Traits::FaceElementType                         FaceElementType;
      typedef typename Traits::FaceElementHandle                       FaceElementHandle;
      
      typedef typename Traits::EdgeElementType                         EdgeElementType;
      typedef typename Traits::EdgeElementHandle                       EdgeElementHandle;
      
      typedef typename Traits::ElementConListType                      ElementConListType;
      typedef typename Traits::ElementConListHandle                    ElementConListHandle;
      
      // ITERATOR DEFINITIONS, BEGIN & END FUNCTIONS
      typedef typename std::vector<VertexHandle>                       VertexMapType;         
      typedef typename VertexMapType::iterator                         VertexMapIterator;     
      typedef typename std::vector<ElementHandle>                      ElementMapType;        
      typedef typename ElementMapType::iterator                        ElementMapIterator;    
      typedef typename std::vector<CohElementHandle>                   CohElementMapType;     
      typedef typename CohElementMapType::iterator                     CohElementMapIterator; 
      typedef typename std::map<FaceElementType, ElementHandle>        FaceMapType;           
      typedef typename FaceMapType::iterator                           FaceMapIterator;       
      typedef typename std::map<EdgeElementType, ElementConListHandle> EdgeMapType;           
      typedef typename EdgeMapType::iterator                           EdgeMapIterator;       
      VertexMapIterator     VertexMapBegin()     { return vertices.begin(); }
      VertexMapIterator     VertexMapEnd()       { return vertices.end(); }
      ElementMapIterator    ElementMapBegin()    { return elements.begin(); }
      ElementMapIterator    ElementMapEnd()      { return elements.end(); }
      CohElementMapIterator CohElementMapBegin() { return cohelements.begin(); }
      CohElementMapIterator CohElementMapEnd()   { return cohelements.end(); }
      FaceMapIterator       FaceMapBegin()       { return faces.begin(); }
      FaceMapIterator       FaceMapEnd()         { return faces.end(); }
      EdgeMapIterator       EdgeMapBegin()       { return edges.begin(); }
      EdgeMapIterator       EdgeMapEnd()         { return edges.end(); }
   
      Mesh() : maxVertex(0), maxElement(0), maxCohElement(0), newPrefix(0) {;}
      ~Mesh() {;}
      
      void FractureFace                               (ElementHandle e, int i); 
      void UpdateEdges                                ();                       
      
      bool ReadFile                                   (std::istream &in);       
      std::string ExportFile                          ();                       
      std::string ExportDomainFile                    (std::set<VertexHandle> part_vert, std::set<ElementHandle> part_elem); 
      
      bool ClearMesh                                  ();                       
      bool RemoveElement                              (ElementHandle e);        
      bool RemoveElements                             (std::vector<int> elems); 
      bool RemoveVertex                               (VertexHandle v);         
      bool RemoveVertices                             (std::vector<int> verts); 
      bool SetActive                                  (std::vector<int> elems); 
      
      VertexHandle FindVertexFromIndex                (int index);              
      ElementHandle FindElementFromIndex              (int index);              
            
      std::vector<VertexHandle>                       GetCentres();             
      
      std::vector<VertexHandle>                       vertices;                 
      std::vector<ElementHandle>                      elements;                 
      std::vector<CohElementHandle>                   cohelements;              
      
      std::vector<VertexHandle>                       vertices_inactive;        
      
      std::map<FaceElementType, ElementHandle>        faces;                    
      std::map<EdgeElementType, ElementConListHandle> edges;                    
   private:
      friend class MeshParalleliser<Traits>;
      
      void ConnectElement(ElementHandle e);
      void AddElementToConLists(ElementHandle e);
      bool AddVertex                                  (VertexHandle v);         
      bool AddElement                                 (ElementHandle e);        
      bool AddCohElement                              (CohElementHandle e);     
      
      std::vector<ElementHandle>                      elements_inactive;        
      
      int maxVertex;     
      int maxElement;    
      int maxCohElement; 
      
      int newPrefix;     
};

} // namespace DAPTA

#include "Mesh.cpp"

#endif

---