mesh_intersection_methods.h

Go to the documentation of this file.

/*
 * intersection_mesh_libmesh.h
 *
 *  Created on: Apr 11, 2016
 *      Author: Thiago Milanetto Schlittler
 */

#ifndef COMMON_INTERSECTIONS_PARALLEL_INTERSECTION_MESH_LIBMESH_H_
#define COMMON_INTERSECTIONS_PARALLEL_INTERSECTION_MESH_LIBMESH_H_

#include "carl_headers.h"
#include "mesh_tables.h"

#include "algorithm"

namespace carl
{

// ***********************
// Mesh_Intersection class
// ***********************

class   Mesh_Intersection
{
protected:
    // Communicators and parallel data
    /*
     *      The global variants are used for the full system
     */
    const libMesh::Parallel::Communicator&  m_comm;     
    const unsigned int                      m_nodes;    
    const unsigned int                      m_rank;     

    const libMesh::Parallel::Communicator&  m_global_comm;  
    const unsigned int                      m_global_nodes; 
    const unsigned int                      m_global_rank;  

    libMesh::ReplicatedMesh&                    m_libMesh_Mesh; 

    libMesh::Mesh                           m_libMesh_PolyhedronMesh;

    DT_3                                    m_CGAL_PolyhedronMesh;

    libMesh::TetGenMeshInterface            m_TetGenInterface;

    // CGAL Kernel converters
    Kernel_to_ExactKernel           ConvertInexactToExact;  
    ExactKernel_to_Kernel           ConvertExactToInexact;  

    unsigned int                                                             m_nb_of_intersections;

    std::unordered_map<unsigned int, std::pair<unsigned int, unsigned int> > m_intersection_pairs;

    std::unordered_map<unsigned int, unsigned int>                           m_intersection_couplings;

    std::unordered_map<unsigned int, std::pair<unsigned int, unsigned int> > m_intersection_element_range;

    // Data structure and variables associated to the "grid" used to collapse
    // elements that are too small.

    double      m_eps;

    double      m_vol_tol;

    std::vector<long > m_GridN;

    std::vector<long > m_dummy_discrete_point;

    libMesh::Point m_Grid_MinPoint;
    
    libMesh::Point m_Grid_MaxPoint;

    std::unordered_map<std::vector<long>, unsigned int, PointHash_3D, PointHash_3D_Equal >
        m_discrete_vertices;

    long m_GridN_min;

    unsigned int m_nb_of_elements;

    unsigned int m_nb_of_vertices;

    std::vector<unsigned int>   m_intersection_point_indexes;

    unsigned int                m_nb_of_points;

    bool m_bMeshFinalized;

    bool m_bPrintDebug;


    IntersectionMeshingMethod m_MeshingMethod;

    Mesh_Intersection();

    // PROTECTED methods
    void update_intersection_mesh();

    void update_intersection_pairs(unsigned int elem_idx_A, unsigned int elem_idx_B, unsigned int inter_id);

    void update_intersection_element_range(unsigned int range_start, unsigned int range_end, unsigned int inter_id);

public:

    // Constructors
    Mesh_Intersection(  libMesh::ReplicatedMesh & mesh, const libMesh::Mesh & mesh_A,
                        const libMesh::Mesh & mesh_B, IntersectionMeshingMethod MeshingMethod = IntersectionMeshingMethod::CGAL,
                        int map_preallocation = 1E6, long grid_n_min = static_cast<long>(1E9), bool debugOutput = false) :
        m_comm { mesh.comm() },
        m_nodes { m_comm.size() },
        m_rank { m_comm.rank() },
        m_global_comm { mesh_A.comm() },
        m_global_nodes { m_global_comm.size() },
        m_global_rank { m_global_comm.rank() },
        m_libMesh_Mesh { mesh },
        m_libMesh_PolyhedronMesh { libMesh::Mesh(m_comm) },
        m_TetGenInterface { libMesh::TetGenMeshInterface(m_libMesh_PolyhedronMesh) },
        m_nb_of_intersections { 0 },
        m_eps { -1 },
        m_GridN { std::vector<long >(3,-1) },
        m_dummy_discrete_point { std::vector<long >(3,-1) },
        m_Grid_MinPoint { libMesh::Point(0,0,0) },
        m_Grid_MaxPoint { libMesh::Point(1,1,1) },
        m_GridN_min { grid_n_min },
        m_nb_of_elements { 0 },
        m_nb_of_vertices { 0 },
        m_nb_of_points { 0 },
        m_bMeshFinalized { false },
        m_bPrintDebug { debugOutput },
        m_MeshingMethod { MeshingMethod }
    {
        m_discrete_vertices.reserve(map_preallocation);
        m_intersection_point_indexes.resize(24);

        set_grid_constraints(mesh_A,mesh_B);

        m_libMesh_Mesh.reserve_nodes(map_preallocation);
        m_libMesh_Mesh.reserve_elem(10*map_preallocation);

        m_intersection_pairs.reserve(map_preallocation);
        m_intersection_couplings.reserve(map_preallocation);
        m_intersection_element_range.reserve(map_preallocation);

        m_libMesh_Mesh.allow_renumbering(false);

        switch(m_MeshingMethod)
        {
        case IntersectionMeshingMethod::LIBMESH_TETGEN :
            std::cout << " -> Using TetGen to generate mesh" << std::endl;
            break;
        case IntersectionMeshingMethod::CGAL :
            std::cout << " -> Using CGAL to generate mesh" << std::endl;
            break;
        }
    };

    // Getters
    const libMesh::ReplicatedMesh & mesh();     
    libMesh::Point & min_point();               
    libMesh::Point & max_point();               
    double eps();                       
    double min_vol();                   
    std::vector<long> & grid_sizes();   
    long grid_min_size();               

    // PUBLIC methods
    void initialize();

    void preallocate_grid( int map_preallocation );

    void set_grid_constraints(const libMesh::Mesh & mesh_A, const libMesh::Mesh & mesh_B, double vol_tol = -1);

    void triangulate_intersection(const std::set<libMesh::Point> & input_points);

    void increase_intersection_mesh(    const std::set<libMesh::Point> & input_points,
                                        unsigned int elem_idx_A,
                                        unsigned int elem_idx_B,
                                        unsigned int elem_idx_C);

    void export_intersection_data(const std::string & filename_base, const std::string & mesh_format = std::string(".e"));

    void prepare_for_use();

    double get_total_volume();

    double get_intersection_volume(std::set<libMesh::Point> & input_points);

    void convert_to_discrete(const libMesh::Point& iPoint, std::vector<long>& oPoint);
};
}

#endif /* COMMON_INTERSECTIONS_PARALLEL_INTERSECTION_MESH_LIBMESH_H_ */