elem/Tetra4.hpp

#ifndef __TETRA4_HPP__
#define __TETRA4_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 Tetra4 {
   public:
      typedef V                             VertexType;
      typedef V*                            VertexHandle;
      typedef Tetra4<V>                     ElementType;
      typedef Tetra4<V>*                    ElementHandle;
      typedef CohElem<Tetra4<V> >           CohElementType;
      typedef CohElementType*               CohElementHandle;
      typedef Simplex<V,3>                  FaceElementType;
      typedef FaceElementType*              FaceElementHandle;
      typedef Simplex<V,2>                  EdgeElementType;
      typedef EdgeElementType*              EdgeElementHandle;
      typedef ElementConList                ElementConListType;
      typedef ElementConListType*           ElementConListHandle;
      
      static const int num_vertices = 4;
      static const int num_adjacents = 4;
      static const int num_edges = 6;
      
      static const std::string deck_keyword; 
      
      Tetra4(VertexHandle v1, VertexHandle v2, VertexHandle v3, VertexHandle v4);
      Tetra4(boost::array<VertexHandle, num_vertices> nodes);
      Tetra4() : globalID(0) {;}
      ~Tetra4() {;}
      
      int                          FindVertex(VertexHandle v);                                               
      ElementHandle                AdjElement(VertexHandle v)     { return AdjElement(FindVertex(v)); }      
      ElementHandle                AdjElement(int i)              { return adjacents.at(i); }                
      
      bool                         IsBoundaryEdge(VertexHandle v1, VertexHandle v2);                         
      bool                         IsBoundaryEdge(int v1, int v2);                                           
      bool                         IsBoundaryFace(VertexHandle v) { return IsBoundaryFace(FindVertex(v)); }  
      bool                         IsBoundaryFace(int i)          { return (adjacents.at(i) == NULL); }      

      ElementHandle                NextTetOnEdge(int &v1, int &v2, int &f);                                  
      int                          FaceToVertex(VertexHandle v1, VertexHandle v2, VertexHandle v3);          
      int                          FaceToVertex(int v1, int v2, int v3);                                     
      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);                                         
      ElementHandle                PrevOnEdge(EdgeElementType 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 Tetra4<V>::deck_keyword = "TETRA4";

} // namespace DAPTA

#include "Tetra4.cpp"

#endif

---