stitch_meshes.h

Go to the documentation of this file.

/*
 * stitch_meshes.h
 *
 *  Created on: Jun 2, 2016
 *      Author: Thiago Milanetto Schlittler
 */

#ifndef COMMON_INTERSECTIONS_PARALLEL_STITCH_MESHES_H_
#define COMMON_INTERSECTIONS_PARALLEL_STITCH_MESHES_H_

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

namespace carl
{

// *******************
// Stitch_Meshes class
// *******************

class   Stitch_Meshes
{
protected:
    // Communicators and parallel data.
    const libMesh::Parallel::Communicator&  m_world_comm;   
    const unsigned int                      m_nodes;        
    const unsigned int                      m_rank;         

    libMesh::ReplicatedMesh&                    m_Stitched_mesh;

    std::vector<std::string>                m_mesh_filenames;

    std::vector<std::string>                m_table_filenames;

    unsigned int                            m_nb_files;

    // Output files
    std::string                             m_base_output;  
    std::string                             m_mesh_output;  
    std::string                             m_table_output; 

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

    // Unordered sets containing the elements from each mesh involved
    // in the intersection
    std::unordered_set<unsigned int> m_restriction_set_first;   
    std::unordered_set<unsigned int> m_restriction_set_second;  

    std::vector<unsigned int> m_intersection_nb_of_elements;

    // Data structure and variables associated to the "grid" used to collapse
    // elements that are too small - reproduces the Mesh_Intersection class!

    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;

    // Parameters of the final mesh
    unsigned int m_nb_of_intersections; 
    unsigned int m_nb_of_elements;      
    unsigned int m_nb_of_nodes;         
    unsigned int m_maximum_nb_of_nodes; 

    // Boolean set when the filename base is also set
    bool m_bFilenamesSet; 

    // Boolean set when the grid is defined
    bool m_bGridDefined;        
    bool m_bGridPreallocated;   

    // Boolean controlling if the stitched intersection mesh was finished
    bool m_bMeshFinalized;      

    // Perflog and debug variables
    bool m_bPrintDebug;     

    // PROTECTED constructor
    Stitch_Meshes();

    // PROTECTED methods

public:

    // Constructors
    Stitch_Meshes(  libMesh::Mesh& output_mesh, const std::string output_filename = "test_stitched",  long grid_n_min = static_cast<long>(1E9), bool debugOutput = true) :
        m_world_comm { output_mesh.comm() },
        m_nodes { m_world_comm.size() },
        m_rank { m_world_comm.rank() },
        m_Stitched_mesh { output_mesh },
        m_nb_files { 0 },
        m_base_output { output_filename },
        m_eps { -1 },
        m_vol_tol { -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_intersections { 0 },
        m_nb_of_elements { 0 },
        m_nb_of_nodes { 0 },
        m_maximum_nb_of_nodes { 0 },
        m_bFilenamesSet { false },
        m_bGridDefined { false },
        m_bGridPreallocated { false },
        m_bMeshFinalized { false },
        m_bPrintDebug { debugOutput }
    {
        m_Stitched_mesh.allow_renumbering(false);
    };

    const libMesh::ReplicatedMesh & mesh();

    const std::unordered_set<unsigned int>* get_restricted_set_pointer_first();

    const std::unordered_set<unsigned int>* get_restricted_set_pointer_second();

    // PUBLIC methods
    void set_base_filenames(std::vector<std::string> & mesh_filenames, std::vector<std::string> & table_filenames);

    void set_base_filenames(const std::string & filename_base = std::string("test_r_"), const std::string & mesh_format = std::string(".msh"), unsigned int nb_of_files = 0);

    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 set_grid_constraints(Mesh_Intersection & mesh_inter_obj);

    void join_tables();

    void stitch_meshes();

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


};
}

#endif /* COMMON_INTERSECTIONS_PARALLEL_STITCH_MESHES_H_ */