carl::Patch_construction Class Reference

Class used to build a mesh patch from a parent mesh and an coupling mesh element. More...

#include <patch_construction.h>

Inheritance diagram for carl::Patch_construction:

Public Member Functions
	Patch_construction (libMesh::Mesh &mesh, const libMesh::Parallel::Communicator &local_comm, bool debugOutput=false)
	Constructor with a pre-defined parent mesh and a local communicator. More...
libMesh::ReplicatedMesh &	parent_mesh ()
	Returns the parent mesh. More...
libMesh::ReplicatedMesh &	patch_mesh ()
	Returns the patch mesh. More...
std::unordered_set< unsigned int > &	elem_indexes ()
	Returns the set of elements inside the patch. More...
std::unordered_set< unsigned int > &	node_indexes ()
	Returns the set of nodes inside the patch. More...
unsigned int	size ()
	Returns the number of elements inside the patch. More...
const libMesh::Elem *	elem (unsigned int idx)
std::unordered_map< unsigned int, std::unordered_set< unsigned int > > &	patch_elem_neighbours ()
	Returns the patch mesh element neighbour table. More...
void	BuildPatch (const libMesh::Elem *Query_elem)
	Build the patch mesh covering a given "Query_elem". More...
unsigned int	convert_parent_to_patch_elem_id (unsigned int input)
	Convert an element index from the parent mesh to the patch mesh. More...
unsigned int	convert_patch_to_parent_elem_id (unsigned int input)
	Convert an element index from the patch mesh to the parent mesh. More...
void	export_patch_mesh (std::string &filename_base)
	Export the patch mesh to a file. More...
unsigned int	current_elem_id ()
const libMesh::Elem *	current_elem_pointer ()
void	intersection_queue_push_back (unsigned int elem_id)
	[ADV. FRONT] Push back element to the deque containing the elements to be treated. More...
void	set_elem_as_treated (unsigned int elem_id)
	[ADV. FRONT] Mark element as already treated. More...
void	set_elem_as_inside_queue (unsigned int elem_id)
	[ADV. FRONT] Mark element as already inside the deque of elements to be treated. More...
bool	intersection_queue_empty ()
	[ADV. FRONT] Check if deque of elements to be treated is empty. More...
bool	test_queue_empty ()
	[ADV. FRONT] Check if deque of elements to be tested is empty. More...
unsigned int	intersection_queue_extract_front_elem ()
	[ADV. FRONT] Pop and returns the first element to be treated. More...
unsigned int	test_queue_extract_front_elem ()
	[ADV. FRONT] Pop and returns the first element to be tested. More...
std::unordered_set< unsigned int > &	neighbors_to_search_next_pair ()
	[ADV. FRONT] Returns the current element's neighbors that must be tested yet. More...
bool	set_neighbors_to_search_next_pairs ()
	[ADV. FRONT] Set the list of neighbors of the current element that must be tested yet. More...
void	add_neighbors_to_test_list ()
	[ADV. FRONT] Adds element to test list. More...
void	FrontSearch_initialize ()
	[ADV. FRONT] Initialize the advancing front search data structures. More...
void	FrontSearch_reset ()
	[ADV. FRONT] Reset the advancing front search data structures, with the exception of list of elements to be treated (should be joined to "FrontSearch_prepare_for_probed_test") More...
unsigned int	FrontSearch_prepare_for_probed_test ()
	[ADV. FRONT] Reset the advancing front search data structures, with the exception of list of elements to be treated. More...

Protected Member Functions
	Patch_construction ()
void	insert_patch_element (const libMesh::Elem *Patch_elem)
	Insert an parent mesh element inside the patch, updating the data structures. More...
void	build_patch_mesh ()
	Build a patch mesh from the patch data structures. More...

Protected Attributes
const libMesh::Parallel::Communicator &	m_comm
	Parent mesh communicator. More...
const unsigned int	m_nodes
	Parent mesh number of processors. More...
const unsigned int	m_rank
	Parent mesh processor rank. More...
const libMesh::Parallel::Communicator &	m_local_comm
	Patch mesh communicator. More...
libMesh::ReplicatedMesh &	m_Mesh_parent
	Parent mesh. More...
libMesh::ReplicatedMesh	m_Mesh_patch
	Patch mesh. More...
std::unique_ptr< libMesh::PointLocatorBase >	m_Parent_Point_Locator
	Parent mesh point locator. More...
Intersection_Tools	m_Intersection_Test
	Intersection search and construction tools. More...
std::unordered_set< unsigned int >	m_Patch_Elem_indexes
	Set of elements inside the patch. More...
std::unordered_set< unsigned int >	m_Patch_Node_indexes
	Set of nodes inside the patch. More...
std::unordered_map< unsigned int, std::unordered_set< unsigned int > >	m_Patch_Elem_Neighbours
	Element neighbour table for the patch. More...
unsigned int	m_working_element_id
	[ADV. FRONT] Index of the patch element currently being tested More...
bool	m_bTestNeighsForNewPairs
	!!! More...
std::deque< int >	m_element_intersection_queue
	[ADV. FRONT] Deque containing the elements to be treated. More...
std::deque< int >	m_element_test_queue
	[ADV. FRONT] Deque containing the elements to be tested More...
std::unordered_map< unsigned int, int >	m_element_already_treated
	[ADV. FRONT] Marks if an element was already treated or not More...
std::unordered_map< unsigned int, int >	m_element_inside_intersection_queue
	[ADV. FRONT] Marks if an element is already inside "m_element_intersection_queue" More...
std::unordered_set< unsigned int >	m_element_neighbours_to_search
	[ADV. FRONT] Set containing the current element's neighbors that must be tested yet. More...
std::unordered_map< unsigned int, int >	m_node_map_Parent_to_Patch
	Mapping between the parent and patch mesh nodes, using the former as keys. More...
std::unordered_map< unsigned int, int >	m_node_map_Patch_to_Parent
	Mapping between the patch and parent mesh nodes, using the former as keys. More...
std::unordered_map< unsigned int, int >	m_elem_map_Parent_to_Patch
	Mapping between the parent and patch mesh elements, using the former as keys. More...
std::unordered_map< unsigned int, int >	m_elem_map_Patch_to_Parent
	Mapping between the patch and parent mesh elements, using the former as keys. More...
bool	m_bPrintDebug
	Print debug information? Default: false. More...

Detailed Description

Class used to build a mesh patch from a parent mesh and an coupling mesh element.

Other than saving and building the mesh patch, this class contains some access methods and data structures adapted to the advancing front intersection search method. These methods are marked with [ADV. FRONT] (Idea: transfer those to their own class ...)

References:

1. Gander, M.J., Japhet, C.: An Algorithm for Non- Matching Grid Projections with Linear Complexity. In: M. Bercovier, M.J. Gander, R. Kornhuber, O. Widlund (eds.) Domain Decomposition Methods in Science and Engineering XVIII, no. 70 in Lecture Notes in Computational Science and Engineering, pp. 185{192. Springer Berlin Heidelberg (2009). URL http://link.springer. com/chapter/10.1007/978-3-642-02677-5_19. DOI: 10.1007/978-3-642-02677-5 19

Definition at line 42 of file patch_construction.h.

Constructor & Destructor Documentation

carl::Patch_construction::Patch_construction ( )

protected

carl::Patch_construction::Patch_construction ( libMesh::Mesh &  mesh, const libMesh::Parallel::Communicator &  local_comm, bool  debugOutput = false  )

inline

Constructor with a pre-defined parent mesh and a local communicator.

Definition at line 142 of file patch_construction.h.

                                                                                                                    :
        m_comm { mesh.comm() },
        m_nodes { m_comm.size() },
        m_rank { m_comm.rank() },
        m_local_comm {  local_comm },
        m_Mesh_parent { mesh },
        m_Mesh_patch { libMesh::ReplicatedMesh(m_local_comm) },

        m_bPrintDebug { debugOutput }
    {
        m_Parent_Point_Locator = m_Mesh_parent.sub_point_locator();

        //  Instruction needed to avoid the code from crashing if a query is outside the mesh
        m_Parent_Point_Locator->enable_out_of_mesh_mode();

        m_working_element_id = 0;
        m_bTestNeighsForNewPairs = true;

        m_Patch_Elem_indexes.reserve(m_Mesh_parent.n_elem());
        m_Patch_Node_indexes.reserve(m_Mesh_parent.n_nodes());
    };

Member Function Documentation

void carl::Patch_construction::add_neighbors_to_test_list

(

)

[ADV. FRONT] Adds element to test list.

Definition at line 303 of file patch_construction.cpp.

{
    std::unordered_set<unsigned int>::iterator it_neigh, it_neigh_end;

    it_neigh        = m_Patch_Elem_Neighbours[m_working_element_id].begin();
    it_neigh_end    = m_Patch_Elem_Neighbours[m_working_element_id].end();

    for( ; it_neigh != it_neigh_end; ++ it_neigh)
    {
        if( m_element_already_treated[*it_neigh] == 0 )
        {
            // New element!
            m_element_test_queue.push_back(*it_neigh);
            m_element_already_treated[*it_neigh] = 1;
        }
    }
};

void carl::Patch_construction::build_patch_mesh ( )

protected

Build a patch mesh from the patch data structures.

Definition at line 393 of file patch_construction.cpp.

{
    // Test if the patch is empty
    homemade_assert_msg(!m_Patch_Elem_indexes.empty() || !m_Patch_Node_indexes.empty(),"Patch is empty!");

    // Clear the input mesh
    m_Mesh_patch.clear();

    m_Mesh_patch.reserve_elem(m_Patch_Elem_indexes.size());
    m_Mesh_patch.reserve_nodes(m_Patch_Node_indexes.size());

    m_node_map_Parent_to_Patch.reserve(m_Patch_Node_indexes.size());
    m_node_map_Patch_to_Parent.reserve(m_Patch_Node_indexes.size());
    m_elem_map_Parent_to_Patch.reserve(m_Patch_Elem_indexes.size());
    m_elem_map_Patch_to_Parent.reserve(m_Patch_Elem_indexes.size());

    // Insert the nodes
    std::unordered_set<unsigned int>::iterator it_set     = m_Patch_Node_indexes.begin();
    std::unordered_set<unsigned int>::iterator it_set_end = m_Patch_Node_indexes.end();
    libMesh::Node * dummyNode = NULL;
    unsigned int counter = 0;
    for( ; it_set != it_set_end ; ++it_set)
    {
        dummyNode = m_Mesh_parent.node_ptr(*it_set);
        m_Mesh_patch.add_point(*dummyNode, counter, m_Mesh_parent.processor_id());
        m_node_map_Parent_to_Patch[*it_set] = counter;
        m_node_map_Patch_to_Parent[counter] = *it_set;
        ++counter;
    }

    // Insert the elements
    it_set     = m_Patch_Elem_indexes.begin();
    it_set_end = m_Patch_Elem_indexes.end();
    libMesh::Elem * originalElem = NULL;
    libMesh::Elem * dummyElem = NULL;
    counter = 0;

    unsigned int originalNode = 0;
    unsigned int outputNode = 0;
    for( ; it_set != it_set_end ; ++it_set)
    {
        originalElem = m_Mesh_parent.elem(*it_set);

        if(originalElem->type() == libMesh::TET4)
        {
            dummyElem = m_Mesh_patch.add_elem(new libMesh::Tet4 );
        }
        else if(originalElem->type() == libMesh::HEX8)
        {
            dummyElem = m_Mesh_patch.add_elem(new libMesh::Hex8 );
        }
        else
        {
            homemade_error_msg("Invalid element type!\n");
        }

        for(unsigned int iii = 0; iii < originalElem->n_nodes(); ++iii)
        {
            originalNode = originalElem->node(iii);
            outputNode = m_node_map_Parent_to_Patch[originalNode];
            dummyElem->set_node(iii) = m_Mesh_patch.node_ptr(outputNode);
        }

        m_elem_map_Parent_to_Patch[*it_set] = counter;
        m_elem_map_Patch_to_Parent[counter] = *it_set;
        ++counter;
    }

    m_Mesh_patch.allow_renumbering(false);
    m_Mesh_patch.prepare_for_use();
}

void carl::Patch_construction::BuildPatch

(

const libMesh::Elem *

Query_elem

)

Build the patch mesh covering a given "Query_elem".

The patch is constructed using a variant of Gander's advancing front algorithm [1], using the "Query_elem" as the "mesh" of the outer 'while' loop, and the parent mesh in the inner 'while' loop. First, the list of elements from the parent mesh forming the patch is filled, and then the patch mesh is constructed using "Patch_construction::build_patch_mesh()"

Definition at line 57 of file patch_construction.cpp.

{
    bool bDoIntersect = false;

    std::set<unsigned int> Intersecting_elems;
    m_Intersection_Test.FindAllIntersection(Query_elem,m_Parent_Point_Locator,Intersecting_elems);

    m_Patch_Elem_indexes.clear();
    m_Patch_Node_indexes.clear();
    m_Patch_Elem_Neighbours.clear();

    // Deque containing the indices of the elements to test
    std::deque<int> Patch_Test_Queue;

    // Unordered set, used to avoid double testing elements
    std::unordered_set<int> Treated_From_Mesh(m_Mesh_parent.n_elem());

    // Index and pointer to element being tested right now
    unsigned int    Tested_idx;

    // Candidate index
    unsigned int    Candidate_idx;

    // First element is ok!
    libMesh::Elem *     First_Patch_elems = NULL;
    libMesh::Elem *     elem_candidate = NULL;
    std::set<unsigned int>::iterator it_set_start = Intersecting_elems.begin();
    for( ; it_set_start != Intersecting_elems.end(); ++it_set_start)
    {
        Treated_From_Mesh.insert(*it_set_start);
        First_Patch_elems = m_Mesh_parent.elem(*it_set_start);
        insert_patch_element(First_Patch_elems);

        for(unsigned int iii = 0; iii < First_Patch_elems->n_neighbors(); ++iii)
        {
            elem_candidate = First_Patch_elems->neighbor(iii);
            if(elem_candidate != NULL)
            {
                Patch_Test_Queue.push_back(elem_candidate->id());
                Treated_From_Mesh.insert(elem_candidate->id());
            }
        }
    }

    // Debug vars
    int nbOfTests = 1;
    int nbOfPositiveTests = 1;

    while(!Patch_Test_Queue.empty())
    {
        // Extract element from the list
        Tested_idx = Patch_Test_Queue[0];
        Patch_Test_Queue.pop_front();
        const libMesh::Elem     * Tested_elem = m_Mesh_parent.elem(Tested_idx);

        // Test it
        bDoIntersect = m_Intersection_Test.libMesh_exact_do_intersect(Query_elem,Tested_elem);
        ++nbOfTests;

        // If it does intersect ...
        if(bDoIntersect)
        {
            ++nbOfPositiveTests;

            // Add it to the output list ...
            insert_patch_element(Tested_elem);

            // ... And add its neighbours (if they weren't tested yet)
            for(unsigned int iii = 0; iii < Tested_elem->n_neighbors(); ++iii)
            {
                elem_candidate = Tested_elem->neighbor(iii);
                if(elem_candidate != NULL)
                {
                    Candidate_idx = elem_candidate->id();
                    if(Treated_From_Mesh.find(Candidate_idx)==Treated_From_Mesh.end())
                    {
                        Patch_Test_Queue.push_back(Candidate_idx);
                        Treated_From_Mesh.insert(Candidate_idx);
                    }
                }
            }
        }
    }

    // Now, let us build the patch's neighbour table
    std::unordered_set<unsigned int> dummy_neighbour_set(12);

    std::unordered_set<unsigned int>::iterator it_set = m_Patch_Elem_indexes.begin();
    std::unordered_set<unsigned int>::iterator it_set_end = m_Patch_Elem_indexes.end();
    m_Patch_Elem_Neighbours.reserve(m_Patch_Elem_indexes.size());

    libMesh::Elem * elem_neighbour;
    unsigned int elem_neighbour_id;

    for( ; it_set != it_set_end; ++it_set)
    {
        const libMesh::Elem     * elem = m_Mesh_parent.elem(*it_set);
        dummy_neighbour_set.clear();

        for(unsigned int iii = 0; iii < elem->n_neighbors(); ++iii)
        {
            elem_neighbour = elem->neighbor(iii);

            if(elem_neighbour != NULL)
            {
                // Then test if it is inside the patch
                elem_neighbour_id = elem_neighbour->id();
                if(m_Patch_Elem_indexes.find(elem_neighbour_id) != m_Patch_Elem_indexes.end())
                {
                    // Then the neighbor is inside the patch, insert it
                    dummy_neighbour_set.insert(elem_neighbour->id());
                }
            }
        }
        m_Patch_Elem_Neighbours.insert(std::pair<unsigned int,std::unordered_set<unsigned int> >(*it_set,dummy_neighbour_set));
    }

    // Build the patch mesh
    this->build_patch_mesh();

    if(m_bPrintDebug)
    {
        std::cout << "    DEBUG: patch search results" << std::endl;
        std::cout << " -> Nb. of intersections found : " << m_Patch_Elem_indexes.size() << std::endl << std::endl;

        std::cout << " -> Nb. of mesh elements       : " << m_Mesh_parent.n_elem() << std::endl;
        std::cout << " -> Nb. of patch elements      : " << m_Patch_Elem_indexes.size() << std::endl;
        std::cout << " -> Patch elem %               : " << 100.*m_Patch_Elem_indexes.size()/m_Mesh_parent.n_elem() << " %" << std::endl << std::endl;

        std::cout << " -> Nb. of mesh nodes          : " << m_Mesh_parent.n_nodes() << std::endl;
        std::cout << " -> Nb. of patch nodes         : " << m_Patch_Node_indexes.size() << std::endl;
        std::cout << " -> Patch node %               : " << 100.*m_Patch_Node_indexes.size()/m_Mesh_parent.n_nodes() << " %" << std::endl << std::endl;

        std::cout << " -> Nb. of tests               : " << nbOfTests << std::endl;
        std::cout << " -> Nb. of positive tests      : " << nbOfPositiveTests << std::endl;
        std::cout << " -> Positive %                 : " << 100.*nbOfPositiveTests/nbOfTests << " %" << std::endl << std::endl;
    }
}

unsigned int carl::Patch_construction::convert_parent_to_patch_elem_id

(

unsigned int

input

)

Convert an element index from the parent mesh to the patch mesh.

Definition at line 249 of file patch_construction.cpp.

{
    return m_elem_map_Parent_to_Patch[input];
}

unsigned int carl::Patch_construction::convert_patch_to_parent_elem_id

(

unsigned int

input

)

Convert an element index from the patch mesh to the parent mesh.

Definition at line 254 of file patch_construction.cpp.

{
    return m_elem_map_Patch_to_Parent[input];
}

unsigned int carl::Patch_construction::current_elem_id

(

)

Definition at line 244 of file patch_construction.cpp.

{
    return m_working_element_id;
};

const libMesh::Elem * carl::Patch_construction::current_elem_pointer

(

)

Definition at line 259 of file patch_construction.cpp.

{
    return m_Mesh_parent.elem(m_working_element_id);
}

const libMesh::Elem * carl::Patch_construction::elem

(

unsigned int

idx

)

Returns an element of the PARENT mesh.

Definition at line 38 of file patch_construction.cpp.

{
    return m_Mesh_parent.elem(idx);
}

std::unordered_set< unsigned int > & carl::Patch_construction::elem_indexes

(

)

Returns the set of elements inside the patch.

Definition at line 23 of file patch_construction.cpp.

{
    return m_Patch_Elem_indexes;
};

void carl::Patch_construction::export_patch_mesh

(

std::string &

filename_base

)

Export the patch mesh to a file.

Definition at line 465 of file patch_construction.cpp.

{
    std::string filename_mesh = filename_base + ".msh";
    m_Mesh_patch.write(filename_mesh);

    std::string filename_elements = filename_base + "_elements__global_to_patch.dat";
    std::string filename_nodes = filename_base + "_nodes__global_to_patch.dat";

    std::ofstream elems_out(filename_elements);
    std::ofstream nodes_out(filename_nodes);

    elems_out << m_elem_map_Patch_to_Parent.size() << std::endl;
    for(unsigned int iii = 0; iii < m_elem_map_Patch_to_Parent.size(); ++iii)
    {
        elems_out << m_elem_map_Patch_to_Parent[iii] << " " << iii << std::endl;
    }

    elems_out.close();

    nodes_out << m_node_map_Patch_to_Parent.size() << std::endl;
    for(unsigned int iii = 0; iii < m_node_map_Patch_to_Parent.size(); ++iii)
    {
        nodes_out << m_node_map_Patch_to_Parent[iii] << " " << iii << std::endl;
    }

    nodes_out.close();
}

void carl::Patch_construction::FrontSearch_initialize

(

)

[ADV. FRONT] Initialize the advancing front search data structures.

Definition at line 324 of file patch_construction.cpp.

{
    homemade_assert_msg(!m_Patch_Elem_indexes.empty() || !m_Patch_Node_indexes.empty(),"Patch is empty!");

    m_element_intersection_queue.clear();
    m_element_test_queue.clear();

    m_element_already_treated.clear();
    m_element_inside_intersection_queue.clear();

    m_element_already_treated.reserve(2*m_Patch_Elem_indexes.size());
    m_element_inside_intersection_queue.reserve(2*m_Patch_Elem_indexes.size());

    m_element_neighbours_to_search.clear();
    m_element_neighbours_to_search.reserve(12);

    std::unordered_set<unsigned int>::iterator it_idx, it_idx_end;
    it_idx      = m_Patch_Elem_indexes.begin();
    it_idx_end  = m_Patch_Elem_indexes.end();

    for( ; it_idx != it_idx_end; ++it_idx)
    {
        m_element_already_treated[*it_idx] = 0;
        m_element_inside_intersection_queue[*it_idx] = 0;
    }

    m_working_element_id = 0;
}

unsigned int carl::Patch_construction::FrontSearch_prepare_for_probed_test

(

)

[ADV. FRONT] Reset the advancing front search data structures, with the exception of list of elements to be treated.

This method is called before starting the inner loop of the advancing front algorithm.

Definition at line 378 of file patch_construction.cpp.

{
    // Extract the intersection queue's first element
    intersection_queue_extract_front_elem();

    // Add it to the test queue
    m_element_test_queue.clear();
    m_element_test_queue.push_back(m_working_element_id);

    return m_working_element_id;
}

void carl::Patch_construction::FrontSearch_reset

(

)

[ADV. FRONT] Reset the advancing front search data structures, with the exception of list of elements to be treated (should be joined to "FrontSearch_prepare_for_probed_test")

This method is called before starting the inner loop of the advancing front algorithm.

Definition at line 356 of file patch_construction.cpp.

{
    homemade_assert_msg(!m_Patch_Elem_indexes.empty() || !m_Patch_Node_indexes.empty(),"Patch is empty!");

    m_element_test_queue.clear();

    std::unordered_set<unsigned int>::iterator it_idx, it_idx_end;
    it_idx      = m_Patch_Elem_indexes.begin();
    it_idx_end  = m_Patch_Elem_indexes.end();

    for( ; it_idx != it_idx_end; ++it_idx)
    {
        m_element_already_treated[*it_idx] = 0;
        m_element_inside_intersection_queue[*it_idx] = 0;
    }

    m_working_element_id = 0;
}

void carl::Patch_construction::insert_patch_element ( const libMesh::Elem *  Patch_elem )

protected

Insert an parent mesh element inside the patch, updating the data structures.

Definition at line 48 of file patch_construction.cpp.

{
    m_Patch_Elem_indexes.insert(Patch_elem->id());
    for(unsigned int iii = 0; iii < Patch_elem->n_nodes(); ++iii)
    {
        m_Patch_Node_indexes.insert(Patch_elem->node(iii));
    }
}

bool carl::Patch_construction::intersection_queue_empty

(

)

[ADV. FRONT] Check if deque of elements to be treated is empty.

Definition at line 220 of file patch_construction.cpp.

{
    return m_element_intersection_queue.empty();
}

unsigned int carl::Patch_construction::intersection_queue_extract_front_elem

(

)

[ADV. FRONT] Pop and returns the first element to be treated.

Definition at line 230 of file patch_construction.cpp.

{
    m_working_element_id = m_element_intersection_queue[0];
    m_element_intersection_queue.pop_front();
    return m_working_element_id;
}

void carl::Patch_construction::intersection_queue_push_back

(

unsigned int

elem_id

)

[ADV. FRONT] Push back element to the deque containing the elements to be treated.

Definition at line 205 of file patch_construction.cpp.

{
    m_element_intersection_queue.push_back(elem_id);
}

std::unordered_set< unsigned int > & carl::Patch_construction::neighbors_to_search_next_pair

(

)

[ADV. FRONT] Returns the current element's neighbors that must be tested yet.

Definition at line 264 of file patch_construction.cpp.

{
    return m_element_neighbours_to_search;
}

std::unordered_set< unsigned int > & carl::Patch_construction::node_indexes

(

)

Returns the set of nodes inside the patch.

Definition at line 28 of file patch_construction.cpp.

{
    return m_Patch_Node_indexes;
};

libMesh::ReplicatedMesh & carl::Patch_construction::parent_mesh

(

)

Returns the parent mesh.

Definition at line 13 of file patch_construction.cpp.

{
    return m_Mesh_parent;
}

std::unordered_map< unsigned int, std::unordered_set< unsigned int > > & carl::Patch_construction::patch_elem_neighbours

(

)

Returns the patch mesh element neighbour table.

Definition at line 43 of file patch_construction.cpp.

{
    return m_Patch_Elem_Neighbours;
}

libMesh::ReplicatedMesh & carl::Patch_construction::patch_mesh

(

)

Returns the patch mesh.

Definition at line 18 of file patch_construction.cpp.

{
    return m_Mesh_patch;
}

void carl::Patch_construction::set_elem_as_inside_queue

(

unsigned int

elem_id

)

[ADV. FRONT] Mark element as already inside the deque of elements to be treated.

Definition at line 215 of file patch_construction.cpp.

{
    m_element_inside_intersection_queue[elem_id] = 1;
}

void carl::Patch_construction::set_elem_as_treated

(

unsigned int

elem_id

)

[ADV. FRONT] Mark element as already treated.

Definition at line 210 of file patch_construction.cpp.

{
    m_element_already_treated[elem_id] = 1;
}

bool carl::Patch_construction::set_neighbors_to_search_next_pairs

(

)

[ADV. FRONT] Set the list of neighbors of the current element that must be tested yet.

Returns a boolean that short-circuits the search of new intersection pairs if the list is empty.

Definition at line 270 of file patch_construction.cpp.

{
    m_bTestNeighsForNewPairs = true;

    // Iterator over all the neighbors
    std::unordered_set<unsigned int>::iterator it_neigh, it_neigh_end;

    it_neigh        = m_Patch_Elem_Neighbours[m_working_element_id].begin();
    it_neigh_end    = m_Patch_Elem_Neighbours[m_working_element_id].end();

    // Clear the "to test" set
    m_element_neighbours_to_search.clear();

    // And fill it, if needed
    for( ; it_neigh != it_neigh_end; ++ it_neigh)
    {
        if( m_element_inside_intersection_queue[*it_neigh] == 0 )
        {
            // This element does not have an initial intersection pair,
            // add it to the list
            m_element_neighbours_to_search.insert(*it_neigh);
        }
    }

    if(m_element_neighbours_to_search.empty())
    {
        // Then do not do the intersection test!
        m_bTestNeighsForNewPairs = false;
    }

    return m_bTestNeighsForNewPairs;
}

unsigned int carl::Patch_construction::size

(

)

Returns the number of elements inside the patch.

Definition at line 33 of file patch_construction.cpp.

{
    return m_Patch_Elem_indexes.size();
}

bool carl::Patch_construction::test_queue_empty

(

)

[ADV. FRONT] Check if deque of elements to be tested is empty.

Definition at line 225 of file patch_construction.cpp.

{
    return m_element_test_queue.empty();
}

unsigned int carl::Patch_construction::test_queue_extract_front_elem

(

)

[ADV. FRONT] Pop and returns the first element to be tested.

Definition at line 237 of file patch_construction.cpp.

{
    m_working_element_id = m_element_test_queue[0];
    m_element_test_queue.pop_front();
    return m_working_element_id;
};

Member Data Documentation

bool carl::Patch_construction::m_bPrintDebug

protected

Print debug information? Default: false.

Definition at line 126 of file patch_construction.h.

bool carl::Patch_construction::m_bTestNeighsForNewPairs

protected

!!!

Definition at line 74 of file patch_construction.h.

const libMesh::Parallel::Communicator& carl::Patch_construction::m_comm

protected

Parent mesh communicator.

Definition at line 47 of file patch_construction.h.

std::unordered_map<unsigned int,int> carl::Patch_construction::m_elem_map_Parent_to_Patch

protected

Mapping between the parent and patch mesh elements, using the former as keys.

Definition at line 120 of file patch_construction.h.

std::unordered_map<unsigned int,int> carl::Patch_construction::m_elem_map_Patch_to_Parent

protected

Mapping between the patch and parent mesh elements, using the former as keys.

Definition at line 123 of file patch_construction.h.

std::unordered_map<unsigned int,int> carl::Patch_construction::m_element_already_treated

protected

[ADV. FRONT] Marks if an element was already treated or not

In [1], this corresponds to "bd" and "ad".

Definition at line 96 of file patch_construction.h.

std::unordered_map<unsigned int,int> carl::Patch_construction::m_element_inside_intersection_queue

protected

[ADV. FRONT] Marks if an element is already inside "m_element_intersection_queue"

This structure is used instead of a search inside "m_element_intersection_queue" due to the inefficiency of doing a search inside a deque.

Definition at line 103 of file patch_construction.h.

std::deque<int> carl::Patch_construction::m_element_intersection_queue

protected

[ADV. FRONT] Deque containing the elements to be treated.

In [1], this corresponds to either "bl" or "bil", depending on whenever the patch is associated to the outer or inner 'while' loop.

Definition at line 82 of file patch_construction.h.

std::unordered_set<unsigned int> carl::Patch_construction::m_element_neighbours_to_search

protected

[ADV. FRONT] Set containing the current element's neighbors that must be tested yet.

In [1], this corresponds to "n".

Definition at line 110 of file patch_construction.h.

std::deque<int> carl::Patch_construction::m_element_test_queue

protected

[ADV. FRONT] Deque containing the elements to be tested

In [1], this corresponds to "al", and is only used for the internal 'while' loop.

Definition at line 89 of file patch_construction.h.

Intersection_Tools carl::Patch_construction::m_Intersection_Test

protected

Intersection search and construction tools.

Definition at line 59 of file patch_construction.h.

const libMesh::Parallel::Communicator& carl::Patch_construction::m_local_comm

protected

Patch mesh communicator.

Definition at line 51 of file patch_construction.h.

libMesh::ReplicatedMesh& carl::Patch_construction::m_Mesh_parent

protected

Parent mesh.

Definition at line 54 of file patch_construction.h.

libMesh::ReplicatedMesh carl::Patch_construction::m_Mesh_patch

protected

Patch mesh.

Definition at line 55 of file patch_construction.h.

std::unordered_map<unsigned int,int> carl::Patch_construction::m_node_map_Parent_to_Patch

protected

Mapping between the parent and patch mesh nodes, using the former as keys.

Definition at line 114 of file patch_construction.h.

std::unordered_map<unsigned int,int> carl::Patch_construction::m_node_map_Patch_to_Parent

protected

Mapping between the patch and parent mesh nodes, using the former as keys.

Definition at line 117 of file patch_construction.h.

const unsigned int carl::Patch_construction::m_nodes

protected

Parent mesh number of processors.

Definition at line 48 of file patch_construction.h.

std::unique_ptr<libMesh::PointLocatorBase> carl::Patch_construction::m_Parent_Point_Locator

protected

Parent mesh point locator.

Definition at line 56 of file patch_construction.h.

std::unordered_set<unsigned int> carl::Patch_construction::m_Patch_Elem_indexes

protected

Set of elements inside the patch.

Definition at line 63 of file patch_construction.h.

std::unordered_map<unsigned int,std::unordered_set<unsigned int> > carl::Patch_construction::m_Patch_Elem_Neighbours

protected

Element neighbour table for the patch.

Definition at line 67 of file patch_construction.h.

std::unordered_set<unsigned int> carl::Patch_construction::m_Patch_Node_indexes

protected

Set of nodes inside the patch.

Definition at line 65 of file patch_construction.h.

const unsigned int carl::Patch_construction::m_rank

protected

Parent mesh processor rank.

Definition at line 49 of file patch_construction.h.

unsigned int carl::Patch_construction::m_working_element_id

protected

[ADV. FRONT] Index of the patch element currently being tested

Definition at line 71 of file patch_construction.h.

---

The documentation for this class was generated from the following files:

• /Users/breubreubreu/Programming/CArl/Cpp/src/include/patch_construction.h
• /Users/breubreubreu/Programming/CArl/Cpp/src/common/intersections_parallel/patch_construction.cpp