MeshUnstructured_decl.hpp

#ifndef MESHUNSTRUCTURED_decl_hpp
#define MESHUNSTRUCTURED_decl_hpp
 
#include "feddlib/core/Utils/FEDDUtils.hpp"
#include "Mesh.hpp"
#include "MeshInterface.hpp"
#include "MeshFileReader.hpp"
#include "feddlib/core/FE/EdgeElements.hpp"
#include "feddlib/core/LinearAlgebra/BlockMatrix.hpp"
#include "feddlib/core/FE/TriangleElements.hpp"
#include "feddlib/core/General/ExporterParaView.hpp"
#include "feddlib/core/LinearAlgebra/MultiVector.hpp"


 
 
 
namespace FEDD {
    
template <class SC = default_sc, class LO = default_lo, class GO = default_go, class NO = default_no>
class MeshUnstructured : public Mesh<SC,LO,GO,NO> {
    
public:
    typedef Mesh<SC,LO,GO,NO> Mesh_Type;
    typedef Teuchos::RCP<MeshUnstructured<SC,LO,GO,NO> > MeshUnstrPtr_Type;
    typedef Teuchos::RCP<Mesh_Type> MeshPtr_Type;
 
    typedef std::vector<MeshUnstrPtr_Type> MeshUnstrPtrArray_Type;
 
    typedef typename Mesh_Type::CommPtr_Type CommPtr_Type;
    typedef typename Mesh_Type::CommConstPtr_Type CommConstPtr_Type;
    typedef typename Mesh_Type::Elements_Type Elements_Type;
    typedef typename Mesh_Type::ElementsPtr_Type ElementsPtr_Type;    
    
    typedef EdgeElements EdgeElements_Type;
    typedef Teuchos::RCP<EdgeElements_Type> EdgeElementsPtr_Type;
 
    typedef SurfaceElements SurfaceElements_Type;
    typedef Teuchos::RCP<SurfaceElements_Type> SurfaceElementsPtr_Type;
    
    typedef MeshInterface<SC,LO,GO,NO> MeshInterface_Type;
    typedef Teuchos::RCP<MeshInterface_Type> MeshInterfacePtr_Type;
    
    typedef Map<LO,GO,NO> Map_Type;
    typedef typename Map_Type::MapPtr_Type MapPtr_Type;
    typedef typename Map_Type::MapConstPtr_Type MapConstPtr_Type;
 
    typedef Teuchos::OrdinalTraits<LO> OTLO;
 
    typedef MultiVector<SC,LO,GO,NO> MultiVector_Type;
    typedef Teuchos::RCP<MultiVector_Type> MultiVectorPtr_Type;
    typedef MultiVector<LO,LO,GO,NO> MultiVectorLO_Type;
    typedef Teuchos::RCP<MultiVectorLO_Type> MultiVectorLOPtr_Type;
    typedef Teuchos::RCP<const MultiVector_Type> MultiVectorPtrConst_Type;
 
    typedef Matrix<SC,LO,GO,NO> Matrix_Type;
    typedef Teuchos::RCP<Matrix_Type> MatrixPtr_Type;
 
    MeshUnstructured();
    
    MeshUnstructured( CommConstPtr_Type comm, int volumeID=10, std::string meshUnit = "cm", bool convertToCM = false );
    
    ~MeshUnstructured();
       
    void buildP2ofP1MeshEdge( MeshUnstrPtr_Type meshP1 );

    void setP2SurfaceElements( MeshUnstrPtr_Type meshP1 );
    
    void setSurfaceP2( FiniteElement &feP2, const FiniteElement &surfFeP1, const vec2D_int_Type &surfacePermutation, int dim );
    
    void addSurfaceP2Nodes( FiniteElement &feP2, const FiniteElement &surfFeP1, const vec2D_int_Type &surfacePermutation, int dim );  
    vec_int_Type reorderP2SurfaceIndices( vec_int_Type& additionalP2IDs, vec_int_Type& index, bool track=false);
    
    void getLocalSurfaceIndices( vec2D_int_Type& surfacePermutation, int surfaceElementOrder );
    
    void getEdgeCombinations( vec2D_int_Type& edgeCombinations );
        
    void determinePositionInElementP2( vec_int_Type& positions, vec_GO_Type& elementsGlobalOfEdge, LO p1ID, LO p2ID, MeshUnstrPtr_Type meshP1 );
    
    int determineFlagP2( FiniteElement& fe, LO p1ID, LO p2ID, vec2D_int_Type& permutation );
    
    int determineFlagP2( LO p1ID, LO p2ID,  LO localEdgeID, vec2D_LO_Type& markedPoint );
    
    void getTriangles(int vertex1ID, int vertex2ID, vec_int_Type &vertices3ID);
 
    SurfaceElementsPtr_Type getSurfaceTriangleElements(){return surfaceTriangleElements_;}
    
    void findSurfaces( const vec_int_Type& elementNodeList, vec_int_Type numbering,  vec2D_int_Type& localSurfaceNodeList_vec, vec_int_Type& locSurfaces, bool critical = false );

    void findEdges( const vec_int_Type& elementNodeList, vec_int_Type numbering,  vec2D_int_Type& localEdgeNodeList_vec, vec_int_Type& locEdges);
    
    MeshInterfacePtr_Type getMeshInterface();        
    
    void buildMeshInterfaceParallelAndDistance( MeshUnstrPtr_Type mesh, vec_int_Type flag_vec, vec_dbl_ptr_Type &distancesToInterface );
    
    void partitionInterface();

    void setEdgeElements(EdgeElementsPtr_Type edgeElements) { edgeElements_ = edgeElements; }

    EdgeElementsPtr_Type getEdgeElements() { return edgeElements_; }

    ElementsPtr_Type getSurfaceEdgeElements() { return surfaceEdgeElements_; }

    void readMeshSize();

    void readMeshEntity(std::string entityType);

    void setMeshFileName(std::string meshFileName, std::string delimiter);

    int getNumGlobalNodes() { return numNodes_; }

    void assignEdgeFlags();

    void buildEdgeMap();

    void exportMesh(MapConstPtr_Type mapUnique, MapConstPtr_Type mapRep, bool exportEdges=false, bool exportSurface=false, std::string meshName="export.mesh");

    void exportNodeFlags();
    
    void exportElementFlags();
 
    /* ###################################################################### */
    
    MeshInterfacePtr_Type meshInterface_;
        
    int volumeID_;
    /* ###################################################################### */
 
 
    EdgeElementsPtr_Type edgeElements_;    
    ElementsPtr_Type surfaceEdgeElements_;
    SurfaceElementsPtr_Type surfaceTriangleElements_;
 
    std::string meshFileName_;
    std::string delimiter_;
 
    int numSurfaces_;
    int numEdges_;
    int numNodes_;
    bool convertToCM_; // Whether to convert it into cm Unit
    std::string meshUnitFinal_; // If converted unit changes
    std::string meshUnitRead_; // Input mesh unit
 
private:
    
    void readSurfaces();
    
    void readLines();
    
    void readElements();
    
    void readNodes();
     
};
}
#endif