intersection_search.h

Go to the documentation of this file.

/*
 * intersection_search.h
 *
 *  Created on: Apr 14, 2016
 *      Author: Thiago Milanetto Schlittler
 */

#ifndef COMMON_INTERSECTIONS_PARALLEL_INTERSECTION_SEARCH_H_
#define COMMON_INTERSECTIONS_PARALLEL_INTERSECTION_SEARCH_H_

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

#include "mesh_intersection_methods.h"
#include "patch_construction.h"

namespace carl
{

// *************************
// Intersection_Search class
// *************************

class   Intersection_Search
{
protected:

    // Mesh addresses
    libMesh::Mesh&                 m_Mesh_A;
    libMesh::Mesh&                 m_Mesh_B;
    libMesh::Mesh&                 m_Mesh_Coupling; 

    // Communicators and parallel data
    const libMesh::Parallel::Communicator& m_comm;          
    const unsigned int                     m_nodes;         
    const unsigned int                     m_rank;          
    const libMesh::Parallel::Communicator& m_local_comm;    

    // Objects containing the two patches
    Patch_construction                     m_Patch_Constructor_A;   
    Patch_construction                     m_Patch_Constructor_B;   

    IntersectionMeshingMethod m_MeshingMethod;  

    Mesh_Intersection                      m_Mesh_Intersection;

    std::unordered_multimap<unsigned int,unsigned int> m_Intersection_Pairs_multimap;

    Intersection_Tools m_Intersection_test;

    Intersection_Tools m_Intersection_test_neighbors;

    std::vector<unsigned int> m_Nb_Of_Intersections_Elem_C;

    libMesh::ErrorVector m_coupling_weights;

    bool m_bSaveInterData;

    bool m_bDidPreliminarySearch;

    bool m_bHavePreallocData;

    bool m_bIntersectionsBuilt;

    double m_Min_Inter_Volume;

    bool m_bSkipIntersectionConstruction;

    bool m_bSkipIntersectionPartitioning;

    std::string m_Output_filename_base;         

    bool MASTER_bPerfLog_intersection_search;   
    libMesh::PerfLog m_perf_log;                
    bool m_bPrintDebug;                         
    bool m_bPrintTimingData;                    
    bool m_bPrintIntersectionsPerPartData;      
    std::string m_timing_data_file_base;        

    // PROTECTED methods
    void BuildCoupledPatches(const libMesh::Elem    * Query_elem, int patch_counter = 0);

    void FindPatchIntersections_Brute(const libMesh::Elem   * Query_elem);

    void FindPatchIntersections_Front(const libMesh::Elem   * Query_elem);

    void FindFirstPair(     Patch_construction *    Patch_guide,
                            Patch_construction *    Patch_probed,
                            std::pair<unsigned int,unsigned int> &      First_intersection);

    void BruteForce_FindFirstPair(  Patch_construction *    Patch_guide,
                                    Patch_construction *    Patch_probed,
                                    std::pair<unsigned int,unsigned int> &      First_intersection);

    void FindAndBuildIntersections_Brute();

    void FindIntersections_Brute();

    void FindAndBuildIntersections_Front();

    void FindIntersections_Front();

    void CalculateIntersectionVolume(const libMesh::Elem    * Query_elem);

    void UpdateCouplingIntersection(const libMesh::Elem     * Query_elem);

public:

    Intersection_Search(libMesh::Mesh & mesh_A,
                        libMesh::Mesh & mesh_B,
                        libMesh::Mesh & mesh_Coupling,
                        libMesh::Mesh & mesh_I,
                        const std::string & output_base = std::string("test"),
                        IntersectionMeshingMethod MeshingMethod = IntersectionMeshingMethod::CGAL,
                        double Min_Inter_Volume = 1E-15,
                        bool  bDoPerf_log = true,
                        bool  bDebugOutput = false) :
        m_Mesh_A { mesh_A },
        m_Mesh_B { mesh_B },
        m_Mesh_Coupling { mesh_Coupling },
        m_comm { m_Mesh_Coupling.comm() },
        m_nodes { m_comm.size() },
        m_rank { m_comm.rank() },
        m_local_comm { mesh_I.comm() },
        m_Patch_Constructor_A { Patch_construction(m_Mesh_A,m_local_comm)},
        m_Patch_Constructor_B { Patch_construction(m_Mesh_B,m_local_comm)},
        m_MeshingMethod { MeshingMethod },
        m_Mesh_Intersection { Mesh_Intersection(mesh_I,m_Mesh_A,m_Mesh_B,m_MeshingMethod)},
        m_bSaveInterData { true },
        m_bDidPreliminarySearch { false },
        m_bHavePreallocData { false },
        m_bIntersectionsBuilt { false },
        m_Min_Inter_Volume { Min_Inter_Volume },
        m_bSkipIntersectionConstruction { false },
        m_bSkipIntersectionPartitioning { false },
        m_Output_filename_base { output_base + "_r_" + std::to_string(m_rank) + "_n_" + std::to_string(m_nodes)},
        MASTER_bPerfLog_intersection_search {bDoPerf_log},
        m_perf_log { libMesh::PerfLog("Intersection search", MASTER_bPerfLog_intersection_search) },
        m_bPrintDebug { bDebugOutput },
        m_bPrintTimingData { false },
        m_bPrintIntersectionsPerPartData { false }
    {
        // Reserve space for the intersection multimap
        m_Nb_Of_Intersections_Elem_C.resize(mesh_Coupling.n_elem(),0);
    };

    libMesh::Mesh & mesh_A();

    libMesh::Mesh & mesh_B();

    libMesh::Mesh & mesh_Coupling();

    // PUBLIC Methods
    void PreparePreallocationAndLoad(SearchMethod search_type = BRUTE);

    void PreallocateAndPartitionCoupling();

    void BuildIntersections(SearchMethod search_type = BRUTE);

    void SetScalingFiles(const std::string& timing_data_file_base);

    void SkipIntersectionConstruction(bool bSkipIntersectionConstruction)
    {
        m_bSkipIntersectionConstruction = bSkipIntersectionConstruction;
    }

    void SkipIntersectionPartitioning(bool bSkipIntersectionPartitioning)
    {
        m_bSkipIntersectionPartitioning = bSkipIntersectionPartitioning;
    }

    void CalculateGlobalVolume();
};
}

#endif /* COMMON_INTERSECTIONS_PARALLEL_INTERSECTION_SEARCH_H_ */