elem/Tri3.hpp

#ifndef __TRI3_HPP__
#define __TRI3_HPP__

#include "elem/Simplex.hpp"
#include "tools/ElementConList.hpp"

#include <vector>
#include <string>

#include <boost/array.hpp>

namespace DAPTA { // Define namespace DAPTA


template <typename V>
class Tri3 {
   public:
      typedef V                             VertexType;
      typedef V*                            VertexHandle;
      typedef Tri3<V>                       ElementType;
      typedef Tri3<V>*                      ElementHandle;
      typedef CohElem<Tri3<V> >             CohElementType;
      typedef CohElementType*               CohElementHandle;
      typedef Simplex<V,2>                  FaceElementType;
      typedef FaceElementType*              FaceElementHandle;
      typedef Simplex<V,1>                  EdgeElementType;
      typedef EdgeElementType*              EdgeElementHandle;
      typedef ElementConList                ElementConListType;
      typedef ElementConListType*           ElementConListHandle;
      
      static const int num_vertices = 3;
      static const int num_adjacents = 3;
      static const int num_edges = 3;
      
      static const std::string deck_keyword; 
      
      Tri3(VertexHandle i, VertexHandle j, VertexHandle k);
      Tri3(boost::array<VertexHandle, num_vertices> nodes);
      Tri3() : globalID(0) {;}
      ~Tri3() {;}
      
      int                          FindVertex(VertexHandle v);                                               
      ElementHandle                AdjElement(VertexHandle v)     { return AdjElement(FindVertex(v)); }      
      ElementHandle                AdjElement(int i)              { return adjacents.at(i); }                
      
      bool                         IsBoundaryNode(VertexHandle v1);                                          
      bool                         IsBoundaryNode(int v1);                                                   
      bool                         IsBoundaryEdge(VertexHandle v1, VertexHandle v2);                         
      bool                         IsBoundaryEdge(int v1, int v2);                                           
      
      ElementHandle                NextTriOnNode(int &v1, int &f);                                           
      int                          FaceToVertex(VertexHandle v1, VertexHandle v2);                           
      int                          FaceToVertex(int v1, int v2);                                             
      int                          FaceToVertex(boost::array<VertexHandle, (num_adjacents-1)> vs);           
      void                         BreakConnection(int f)                          { adjacents.at(f)=NULL; }
      void                         MakeConnection(VertexHandle f, ElementHandle t) { MakeConnection(FindVertex(f), t); }
      void                         MakeConnection(int f, ElementHandle t)          { adjacents.at(f)=t; }
      
      FaceElementType              GetFace(int ind);                                                         
      int                          GetFaceIndex(FaceElementType face);                                       
      EdgeElementType              GetEdge(int ind);                                                         
      int                          GetEdgeIndex(EdgeElementType edge);                                       
      std::vector<EdgeElementType> GetEdges(int f);                                                          
      std::vector<EdgeElementType> GetAllEdges();                                                            
      ElementHandle                NextOnEdge(int ind);                                                      
      ElementHandle                PrevOnEdge(int ind);                                                      
      ElementHandle                NextOnEdge(EdgeElementType edge) {return NextOnEdge(GetEdgeIndex(edge));} 
      ElementHandle                PrevOnEdge(EdgeElementType edge) {return PrevOnEdge(GetEdgeIndex(edge));} 
      CohElementHandle             NextCohOnEdge(int ind);                                                   
      CohElementHandle             PrevCohOnEdge(int ind);                                                   
      
      VertexHandle                 GetCentre();                                                              
      
      boost::array<VertexHandle,num_vertices>      vertices;
      boost::array<ElementHandle,num_adjacents>    adjacents;
      boost::array<CohElementHandle,num_adjacents> coh_adjacents;
      boost::array<ElementConListHandle,num_edges> con_lists;
      
      int globalID;
      
      // OLD FRACTURE ALGORITHMS
      //CohElementHandle             FractureFace(VertexHandle f, std::vector<VertexHandle>* new_vertices, bool &new_elem);
      //CohElementHandle             FractureFace(int f, std::vector<VertexHandle>* new_vertices, bool &new_elem);
   private:
};

template <typename V>
const std::string Tri3<V>::deck_keyword = "TRI3";

} // namespace DAPTA

#include "Tri3.cpp"

#endif

---