Used by the Mesh to keep track of boundary nodes and elements. More...

#include <boundary_info.h>

Inheritance diagram for libMesh::BoundaryInfo:

Public Member Functions
BoundaryInfo &	operator= (const BoundaryInfo &other_boundary_info)

	~BoundaryInfo ()

void	clear ()

void	regenerate_id_sets ()

void	sync (UnstructuredMesh &boundary_mesh)

void	sync (const std::set< boundary_id_type > &requested_boundary_ids, UnstructuredMesh &boundary_mesh)

void	sync (const std::set< boundary_id_type > &requested_boundary_ids, UnstructuredMesh &boundary_mesh, const std::set< subdomain_id_type > &subdomains_relative_to)

void	get_side_and_node_maps (UnstructuredMesh &boundary_mesh, std::map< dof_id_type, dof_id_type > &node_id_map, std::map< dof_id_type, unsigned char > &side_id_map, Real tolerance=1.e-6)

void	add_elements (const std::set< boundary_id_type > &requested_boundary_ids, UnstructuredMesh &boundary_mesh)

void	add_elements (const std::set< boundary_id_type > &requested_boundary_ids, UnstructuredMesh &boundary_mesh, const std::set< subdomain_id_type > &subdomains_relative_to)

void	add_node (const Node *node, const boundary_id_type id)

void	add_node (const dof_id_type node, const boundary_id_type id)

void	add_node (const Node *node, const std::vector< boundary_id_type > &ids)

void	clear_boundary_node_ids ()

void	add_edge (const dof_id_type elem, const unsigned short int edge, const boundary_id_type id)

void	add_edge (const Elem *elem, const unsigned short int edge, const boundary_id_type id)

void	add_edge (const Elem *elem, const unsigned short int edge, const std::vector< boundary_id_type > &ids)

void	add_shellface (const dof_id_type elem, const unsigned short int shellface, const boundary_id_type id)

void	add_shellface (const Elem *elem, const unsigned short int shellface, const boundary_id_type id)

void	add_shellface (const Elem *elem, const unsigned short int shellface, const std::vector< boundary_id_type > &ids)

void	add_side (const dof_id_type elem, const unsigned short int side, const boundary_id_type id)

void	add_side (const Elem *elem, const unsigned short int side, const boundary_id_type id)

void	add_side (const Elem *elem, const unsigned short int side, const std::vector< boundary_id_type > &ids)

void	remove (const Node *node)

void	remove (const Elem *elem)

void	remove_edge (const Elem *elem, const unsigned short int edge)

void	remove_edge (const Elem *elem, const unsigned short int edge, const boundary_id_type id)

void	remove_shellface (const Elem *elem, const unsigned short int shellface)

void	remove_shellface (const Elem *elem, const unsigned short int shellface, const boundary_id_type id)

void	remove_side (const Elem *elem, const unsigned short int side)

void	remove_side (const Elem *elem, const unsigned short int side, const boundary_id_type id)

void	remove_id (boundary_id_type id)

std::size_t	n_boundary_ids () const

bool	has_boundary_id (const Node *const node, const boundary_id_type id) const

std::vector< boundary_id_type >	boundary_ids (const Node *node) const

void	boundary_ids (const Node *node, std::vector< boundary_id_type > &vec_to_fill) const

unsigned int	n_boundary_ids (const Node *node) const

unsigned int	n_edge_boundary_ids (const Elem *const elem, const unsigned short int edge) const

std::vector< boundary_id_type >	edge_boundary_ids (const Elem *const elem, const unsigned short int edge) const

void	edge_boundary_ids (const Elem *const elem, const unsigned short int edge, std::vector< boundary_id_type > &vec_to_fill) const

std::vector< boundary_id_type >	raw_edge_boundary_ids (const Elem *const elem, const unsigned short int edge) const

void	raw_edge_boundary_ids (const Elem *const elem, const unsigned short int edge, std::vector< boundary_id_type > &vec_to_fill) const

unsigned int	n_shellface_boundary_ids (const Elem *const elem, const unsigned short int shellface) const

void	shellface_boundary_ids (const Elem *const elem, const unsigned short int shellface, std::vector< boundary_id_type > &vec_to_fill) const

void	raw_shellface_boundary_ids (const Elem *const elem, const unsigned short int shellface, std::vector< boundary_id_type > &vec_to_fill) const

bool	has_boundary_id (const Elem *const elem, const unsigned short int side, const boundary_id_type id) const

boundary_id_type	boundary_id (const Elem *const elem, const unsigned short int side) const

unsigned int	n_boundary_ids (const Elem *const elem, const unsigned short int side) const

std::vector< boundary_id_type >	boundary_ids (const Elem *const elem, const unsigned short int side) const

void	boundary_ids (const Elem *const elem, const unsigned short int side, std::vector< boundary_id_type > &vec_to_fill) const

std::vector< boundary_id_type >	raw_boundary_ids (const Elem *const elem, const unsigned short int side) const

void	raw_boundary_ids (const Elem *const elem, const unsigned short int side, std::vector< boundary_id_type > &vec_to_fill) const

void	copy_boundary_ids (const BoundaryInfo &old_boundary_info, const Elem const old_elem, const Elem const new_elem)

unsigned int	side_with_boundary_id (const Elem *const elem, const boundary_id_type boundary_id) const

void	build_node_boundary_ids (std::vector< boundary_id_type > &b_ids) const

void	build_side_boundary_ids (std::vector< boundary_id_type > &b_ids) const

void	build_shellface_boundary_ids (std::vector< boundary_id_type > &b_ids) const

std::size_t	n_boundary_conds () const

std::size_t	n_edge_conds () const

std::size_t	n_shellface_conds () const

std::size_t	n_nodeset_conds () const

void	build_node_list (std::vector< dof_id_type > &node_id_list, std::vector< boundary_id_type > &bc_id_list) const

std::vector< std::tuple< dof_id_type, boundary_id_type > >	build_node_list () const

void	build_node_list_from_side_list ()

void	build_side_list_from_node_list ()

void	build_side_list (std::vector< dof_id_type > &element_id_list, std::vector< unsigned short int > &side_list, std::vector< boundary_id_type > &bc_id_list) const

std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > >	build_side_list () const

void	build_active_side_list (std::vector< dof_id_type > &element_id_list, std::vector< unsigned short int > &side_list, std::vector< boundary_id_type > &bc_id_list) const

std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > >	build_active_side_list () const

void	build_edge_list (std::vector< dof_id_type > &element_id_list, std::vector< unsigned short int > &edge_list, std::vector< boundary_id_type > &bc_id_list) const

std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > >	build_edge_list () const

void	build_shellface_list (std::vector< dof_id_type > &element_id_list, std::vector< unsigned short int > &shellface_list, std::vector< boundary_id_type > &bc_id_list) const

std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > >	build_shellface_list () const

const std::set< boundary_id_type > &	get_boundary_ids () const

const std::set< boundary_id_type > &	get_side_boundary_ids () const

const std::set< boundary_id_type > &	get_edge_boundary_ids () const

const std::set< boundary_id_type > &	get_shellface_boundary_ids () const

const std::set< boundary_id_type > &	get_node_boundary_ids () const

void	print_info (std::ostream &out=libMesh::out) const

void	print_summary (std::ostream &out=libMesh::out) const

const std::string &	get_sideset_name (boundary_id_type id) const

std::string &	sideset_name (boundary_id_type id)

const std::string &	get_nodeset_name (boundary_id_type id) const

std::string &	nodeset_name (boundary_id_type id)

boundary_id_type	get_id_by_name (const std::string &name) const

std::map< boundary_id_type, std::string > &	set_sideset_name_map ()

const std::map< boundary_id_type, std::string > &	get_sideset_name_map () const

std::map< boundary_id_type, std::string > &	set_nodeset_name_map ()

const std::map< boundary_id_type, std::string > &	get_nodeset_name_map () const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Attributes
static const boundary_id_type	invalid_id = -123

Protected Member Functions
	BoundaryInfo (MeshBase &m)

Protected Attributes
const Parallel::Communicator &	_communicator

Private Member Functions
void	_find_id_maps (const std::set< boundary_id_type > &requested_boundary_ids, dof_id_type first_free_node_id, std::map< dof_id_type, dof_id_type > node_id_map, dof_id_type first_free_elem_id, std::map< std::pair< dof_id_type, unsigned char >, dof_id_type > side_id_map, const std::set< subdomain_id_type > &subdomains_relative_to)

Private Attributes
MeshBase &	_mesh

std::multimap< const Node *, boundary_id_type >	_boundary_node_id

std::multimap< const Elem *, std::pair< unsigned short int, boundary_id_type > >	_boundary_edge_id

std::multimap< const Elem *, std::pair< unsigned short int, boundary_id_type > >	_boundary_shellface_id

std::multimap< const Elem *, std::pair< unsigned short int, boundary_id_type > >	_boundary_side_id

std::set< boundary_id_type >	_boundary_ids

std::set< boundary_id_type >	_side_boundary_ids

std::set< boundary_id_type >	_edge_boundary_ids

std::set< boundary_id_type >	_node_boundary_ids

std::set< boundary_id_type >	_shellface_boundary_ids

std::map< boundary_id_type, std::string >	_ss_id_to_name

std::map< boundary_id_type, std::string >	_ns_id_to_name

Friends
class	MeshBase

Detailed Description

Used by the Mesh to keep track of boundary nodes and elements.

The BoundaryInfo class contains information relevant to boundary conditions including storing faces, edges, and nodes on the boundary, along with ids that can be used to identify the type of boundary each entity is part of. It can also build a mesh that just includes boundary elements/faces.

Author: Benjamin S. Kirk

Date: 2002

Definition at line 57 of file boundary_info.h.

Constructor & Destructor Documentation

◆ BoundaryInfo()

libMesh::BoundaryInfo::BoundaryInfo ( MeshBase & m )

protected

Constructor. Takes a reference to the mesh. The BoundaryInfo class is only used internally by the Mesh class. A user should never instantiate this class. Therefore the constructor is protected.

Definition at line 49 of file boundary_info.C.

                                        :
   ParallelObject(m.comm()),
   _mesh (m)
 {
 }

◆ ~BoundaryInfo()

libMesh::BoundaryInfo::~BoundaryInfo ( )

Destructor. Not much to do.

Definition at line 100 of file boundary_info.C.

References clear().

 {
   this->clear();
 }

Member Function Documentation

◆ _find_id_maps()

void libMesh::BoundaryInfo::_find_id_maps	(	const std::set< boundary_id_type > &	requested_boundary_ids,
		dof_id_type	first_free_node_id,
		std::map< dof_id_type, dof_id_type > *	node_id_map,
		dof_id_type	first_free_elem_id,
		std::map< std::pair< dof_id_type, unsigned char >, dof_id_type > *	side_id_map,
		const std::set< subdomain_id_type > &	subdomains_relative_to
	)

private

Helper method for finding consistent maps of interior to boundary dof_object ids. Either node_id_map or side_id_map can be nullptr, in which case it will not be filled.

Definition at line 2412 of file boundary_info.C.

References _boundary_side_id, _mesh, libMesh::as_range(), libMesh::Elem::build_side_ptr(), libMesh::ParallelObject::comm(), libMesh::MeshBase::elements_begin(), libMesh::MeshBase::elements_end(), libMesh::DofObject::id(), invalid_id, libMesh::DofObject::invalid_processor_id, libMesh::Elem::invalid_subdomain_id, libMesh::ParallelObject::n_processors(), libMesh::Elem::neighbor_ptr(), libMesh::MeshBase::pid_elements_begin(), libMesh::MeshBase::pid_elements_end(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::Parallel::Communicator::set_union(), side, libMesh::Elem::side_index_range(), libMesh::Elem::subdomain_id(), and libMesh::Elem::top_parent().

Referenced by add_elements(), and sync().

 {
   // We'll do the same modulus trick that DistributedMesh uses to avoid
   // id conflicts between different processors
   dof_id_type
     next_node_id = first_free_node_id + this->processor_id(),
     next_elem_id = first_free_elem_id + this->processor_id();
 
   // Pull objects out of the loop to reduce heap operations
   std::unique_ptr<const Elem> side;
 
   // We'll pass through the mesh once first to build
   // the maps and count boundary nodes and elements.
   // To find local boundary nodes, we have to examine all elements
   // here rather than just local elements, because it's possible to
   // have a local boundary node that's not on a local boundary
   // element, e.g. at the tip of a triangle.
 
   // We'll loop through two different ranges here: first all elements,
   // looking for local nodes, and second through unpartitioned
   // elements, looking for all remaining nodes.
   const MeshBase::const_element_iterator end_el = _mesh.elements_end();
   bool hit_end_el = false;
   const MeshBase::const_element_iterator end_unpartitioned_el =
     _mesh.pid_elements_end(DofObject::invalid_processor_id);
 
   for (MeshBase::const_element_iterator el = _mesh.elements_begin();
        !hit_end_el || (el != end_unpartitioned_el); ++el)
     {
       if ((el == end_el) && !hit_end_el)
         {
           // Note that we're done with local nodes and just looking
           // for remaining unpartitioned nodes
           hit_end_el = true;
 
           // Join up the local results from other processors
           if (side_id_map)
             this->comm().set_union(*side_id_map);
           if (node_id_map)
             this->comm().set_union(*node_id_map);
 
           // Finally we'll pass through any unpartitioned elements to add them
           // to the maps and counts.
           next_node_id = first_free_node_id + this->n_processors();
           next_elem_id = first_free_elem_id + this->n_processors();
 
           el = _mesh.pid_elements_begin(DofObject::invalid_processor_id);
           if (el == end_unpartitioned_el)
             break;
         }
 
       const Elem * elem = *el;
 
       // If the subdomains_relative_to container has the
       // invalid_subdomain_id, we fall back on the "old" behavior of
       // adding sides regardless of this Elem's subdomain. Otherwise,
       // if the subdomains_relative_to container doesn't contain the
       // current Elem's subdomain_id(), we won't add any sides from
       // it.
       if (!subdomains_relative_to.count(Elem::invalid_subdomain_id) &&
           !subdomains_relative_to.count(elem->subdomain_id()))
         continue;
 
       // Get the top-level parent for this element. This is used for
       // searching for boundary sides on this element.
       const Elem * top_parent = elem->top_parent();
 
       // Find all the boundary side ids for this Elem.
       auto bounds = _boundary_side_id.equal_range(top_parent);
 
       for (auto s : elem->side_index_range())
         {
           bool add_this_side = false;
           boundary_id_type this_bcid = invalid_id;
 
           for (const auto & pr : as_range(bounds))
             {
               this_bcid = pr.second.second;
 
               // if this side is flagged with a boundary condition
               // and the user wants this id
               if ((pr.second.first == s) &&
                   (requested_boundary_ids.count(this_bcid)))
                 {
                   add_this_side = true;
                   break;
                 }
             }
 
           // We may still want to add this side if the user called
           // sync() with no requested_boundary_ids. This corresponds
           // to the "old" style of calling sync() in which the entire
           // boundary was copied to the BoundaryMesh, and handles the
           // case where elements on the geometric boundary are not in
           // any sidesets.
           if (bounds.first == bounds.second            &&
               requested_boundary_ids.count(invalid_id) &&
               elem->neighbor_ptr(s) == nullptr)
             add_this_side = true;
 
           if (add_this_side)
             {
               // We only assign ids for our own and for
               // unpartitioned elements
               if (side_id_map &&
                   ((elem->processor_id() == this->processor_id()) ||
                    (elem->processor_id() ==
                     DofObject::invalid_processor_id)))
                 {
                   std::pair<dof_id_type, unsigned char> side_pair(elem->id(), s);
                   libmesh_assert (!side_id_map->count(side_pair));
                   (*side_id_map)[side_pair] = next_elem_id;
                   next_elem_id += this->n_processors() + 1;
                 }
 
               elem->build_side_ptr(side, s);
               for (auto n : side->node_index_range())
                 {
                   const Node & node = side->node_ref(n);
 
                   // In parallel we don't know enough to number
                   // others' nodes ourselves.
                   if (!hit_end_el &&
                       (node.processor_id() != this->processor_id()))
                     continue;
 
                   dof_id_type node_id = node.id();
                   if (node_id_map && !node_id_map->count(node_id))
                     {
                       (*node_id_map)[node_id] = next_node_id;
                       next_node_id += this->n_processors() + 1;
                     }
                 }
             }
         }
     }
 
   // FIXME: ought to renumber side/node_id_map image to be contiguous
   // to save memory, also ought to reserve memory
 }

◆ add_edge() [1/3]

void libMesh::BoundaryInfo::add_edge	(	const dof_id_type	elem,
		const unsigned short int	edge,
		const boundary_id_type	id
	)

Add edge edge of element number elem with boundary id id to the boundary information data structure. Edge-based boundary IDs should only be used in 3D.

Definition at line 670 of file boundary_info.C.

References _mesh, and libMesh::MeshBase::elem_ptr().

Referenced by libMesh::MeshTools::Modification::change_boundary_id(), copy_boundary_ids(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::ReplicatedMesh::stitching_helper(), and libMesh::Parallel::Packing< T >::unpack().

 {
   this->add_edge (_mesh.elem_ptr(e), edge, id);
 }

◆ add_edge() [2/3]

void libMesh::BoundaryInfo::add_edge	(	const Elem *	elem,
		const unsigned short int	edge,
		const boundary_id_type	id
	)

Add edge edge of element elem with boundary id id to the boundary information data structure. Edge-based boundary IDs should only be used in 3D.

Definition at line 679 of file boundary_info.C.

References _boundary_edge_id, _boundary_ids, _edge_boundary_ids, libMesh::as_range(), invalid_id, and libMesh::Elem::level().

 {
   libmesh_assert(elem);
 
   // Only add BCs for level-0 elements.
   libmesh_assert_equal_to (elem->level(), 0);
 
   if (id == invalid_id)
     libmesh_error_msg("ERROR: You may not set a boundary ID of "        \
                       << invalid_id                                     \
                       << "\n That is reserved for internal use.");
 
   // Don't add the same ID twice
   for (const auto & pr : as_range(_boundary_edge_id.equal_range(elem)))
     if (pr.second.first == edge &&
         pr.second.second == id)
       return;
 
   _boundary_edge_id.insert(std::make_pair(elem, std::make_pair(edge, id)));
   _boundary_ids.insert(id);
   _edge_boundary_ids.insert(id); // Also add this ID to the set of edge boundary IDs
 }

◆ add_edge() [3/3]

void libMesh::BoundaryInfo::add_edge	(	const Elem *	elem,
		const unsigned short int	edge,
		const std::vector< boundary_id_type > &	ids
	)

Add edge edge of element elem with boundary ids ids to the boundary information data structure. Edge-based boundary IDs should only be used in 3D.

Definition at line 706 of file boundary_info.C.

References _boundary_edge_id, _boundary_ids, _edge_boundary_ids, libMesh::as_range(), invalid_id, and libMesh::Elem::level().

 {
   if (ids.empty())
     return;
 
   libmesh_assert(elem);
 
   // Only add BCs for level-0 elements.
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Don't add the same ID twice
   auto bounds = _boundary_edge_id.equal_range(elem);
 
   // The entries in the ids vector may be non-unique.  If we expected
   // *lots* of ids, it might be fastest to construct a std::set from
   // the entries, but for a small number of entries, which is more
   // typical, it is probably faster to copy the vector and do sort+unique.
   // http://stackoverflow.com/questions/1041620/whats-the-most-efficient-way-to-erase-duplicates-and-sort-a-vector
   std::vector<boundary_id_type> unique_ids(ids.begin(), ids.end());
   std::sort(unique_ids.begin(), unique_ids.end());
   std::vector<boundary_id_type>::iterator new_end =
     std::unique(unique_ids.begin(), unique_ids.end());
 
   for (auto & id : as_range(unique_ids.begin(), new_end))
     {
       if (id == invalid_id)
         libmesh_error_msg("ERROR: You may not set a boundary ID of "   \
                           << invalid_id                                \
                           << "\n That is reserved for internal use.");
 
       bool already_inserted = false;
       for (const auto & pr : as_range(bounds))
         if (pr.second.first == edge &&
             pr.second.second == id)
           {
             already_inserted = true;
             break;
           }
       if (already_inserted)
         continue;
 
       _boundary_edge_id.insert(std::make_pair(elem, std::make_pair(edge, id)));
       _boundary_ids.insert(id);
       _edge_boundary_ids.insert(id); // Also add this ID to the set of edge boundary IDs
     }
 }

◆ add_elements() [1/2]

void libMesh::BoundaryInfo::add_elements	(	const std::set< boundary_id_type > &	requested_boundary_ids,
		UnstructuredMesh &	boundary_mesh
	)

Generates elements along the boundary of our _mesh, which use pre-existing nodes on the boundary_mesh, and which have interior_parent values properly defined.

The boundary_mesh may be the same as the interior mesh; this generates a mesh with elements of mixed dimension.

Only boundary elements with the specified ids are created.

Definition at line 333 of file boundary_info.C.

References libMesh::Elem::invalid_subdomain_id.

Referenced by sync().

 {
   // Call the 3 argument version of this function with a dummy value for the third arg.
   std::set<subdomain_id_type> subdomains_relative_to;
   subdomains_relative_to.insert(Elem::invalid_subdomain_id);
 
   this->add_elements(requested_boundary_ids,
                      boundary_mesh,
                      subdomains_relative_to);
 }

◆ add_elements() [2/2]

void libMesh::BoundaryInfo::add_elements	(	const std::set< boundary_id_type > &	requested_boundary_ids,
		UnstructuredMesh &	boundary_mesh,
		const std::set< subdomain_id_type > &	subdomains_relative_to
	)

Same as the add_elements() function above, but takes a set of subdomains for which the sides must be relative to. This is necessary to avoid double-adding sides of internal sidesets to the BoundaryMesh.

Definition at line 347 of file boundary_info.C.

References _boundary_side_id, _find_id_maps(), _mesh, libMesh::MeshBase::add_elem(), libMesh::as_range(), libMesh::Elem::build_side_ptr(), libMesh::MeshBase::elem_ptr(), libMesh::MeshBase::element_ptr_range(), libMesh::DofObject::id(), libMesh::Elem::INACTIVE, invalid_id, libMesh::Elem::invalid_subdomain_id, libMesh::Elem::is_node_on_side(), libMesh::MeshBase::is_serial(), libMesh::DistributedMesh::libmesh_assert_valid_parallel_ids(), libMesh::MeshCommunication::make_node_unique_ids_parallel_consistent(), libMesh::MeshBase::max_elem_id(), n_nodes, libMesh::Elem::n_nodes(), libMesh::Elem::n_sides(), libMesh::Elem::n_vertices(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_ptr(), libMesh::MeshBase::parallel_max_unique_id(), libMesh::Elem::parent(), libMesh::Elem::point(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), libMesh::remote_elem, libMesh::Elem::set_interior_parent(), libMesh::Elem::set_neighbor(), libMesh::Elem::set_parent(), side, libMesh::Elem::side_index_range(), and libMesh::Elem::top_parent().

 {
   LOG_SCOPE("add_elements()", "BoundaryInfo");
 
   // We're not prepared to mix serial and distributed meshes in this
   // method, so make sure they match from the start.
   libmesh_assert_equal_to(_mesh.is_serial(),
                           boundary_mesh.is_serial());
 
   std::map<std::pair<dof_id_type, unsigned char>, dof_id_type> side_id_map;
   this->_find_id_maps(requested_boundary_ids,
                       0,
                       nullptr,
                       boundary_mesh.max_elem_id(),
                       &side_id_map,
                       subdomains_relative_to);
 
   // We have to add sides *outside* any element loop, because if
   // boundary_mesh and _mesh are the same then those additions can
   // invalidate our element iterators.  So we just use the element
   // loop to make a list of sides to add.
   typedef std::vector<std::pair<dof_id_type, unsigned char>>
     side_container;
   side_container sides_to_add;
 
   for (const auto & elem : _mesh.element_ptr_range())
     {
       // If the subdomains_relative_to container has the
       // invalid_subdomain_id, we fall back on the "old" behavior of
       // adding sides regardless of this Elem's subdomain. Otherwise,
       // if the subdomains_relative_to container doesn't contain the
       // current Elem's subdomain_id(), we won't add any sides from
       // it.
       if (!subdomains_relative_to.count(Elem::invalid_subdomain_id) &&
           !subdomains_relative_to.count(elem->subdomain_id()))
         continue;
 
       // Get the top-level parent for this element
       const Elem * top_parent = elem->top_parent();
 
       // Find all the boundary side ids for this Elem.
       auto bounds = _boundary_side_id.equal_range(top_parent);
 
       for (auto s : elem->side_index_range())
         {
           bool add_this_side = false;
           boundary_id_type this_bcid = invalid_id;
 
           for (const auto & pr : as_range(bounds))
             {
               this_bcid = pr.second.second;
 
               // if this side is flagged with a boundary condition
               // and the user wants this id
               if ((pr.second.first == s) &&
                   (requested_boundary_ids.count(this_bcid)))
                 {
                   add_this_side = true;
                   break;
                 }
             }
 
           // We may still want to add this side if the user called
           // sync() with no requested_boundary_ids. This corresponds
           // to the "old" style of calling sync() in which the entire
           // boundary was copied to the BoundaryMesh, and handles the
           // case where elements on the geometric boundary are not in
           // any sidesets.
           if (bounds.first == bounds.second            &&
               requested_boundary_ids.count(invalid_id) &&
               elem->neighbor_ptr(s) == nullptr)
             add_this_side = true;
 
           if (add_this_side)
             sides_to_add.push_back(std::make_pair(elem->id(), s));
         }
     }
 
 #ifdef LIBMESH_ENABLE_UNIQUE_ID
   unique_id_type old_max_unique_id = boundary_mesh.parallel_max_unique_id();
 #endif
 
   for (const auto & pr : sides_to_add)
     {
       const dof_id_type elem_id = pr.first;
       const unsigned char s = pr.second;
       Elem * elem = _mesh.elem_ptr(elem_id);
 
       // Build the side - do not use a "proxy" element here:
       // This will be going into the boundary_mesh and needs to
       // stand on its own.
       std::unique_ptr<Elem> side (elem->build_side_ptr(s, false));
 
       side->processor_id() = elem->processor_id();
 
       const std::pair<dof_id_type, unsigned char> side_pair(elem_id, s);
 
       libmesh_assert(side_id_map.count(side_pair));
 
       const dof_id_type new_side_id = side_id_map[side_pair];
 
       side->set_id(new_side_id);
 
 #ifdef LIBMESH_ENABLE_UNIQUE_ID
       side->set_unique_id() = old_max_unique_id + new_side_id;
 #endif
 
       // Add the side
       Elem * new_elem = boundary_mesh.add_elem(side.release());
 
 #ifdef LIBMESH_ENABLE_AMR
       // Set parent links
       if (elem->parent())
         {
           const std::pair<dof_id_type, unsigned char> parent_side_pair(elem->parent()->id(), s);
 
           libmesh_assert(side_id_map.count(parent_side_pair));
 
           Elem * side_parent = boundary_mesh.elem_ptr(side_id_map[parent_side_pair]);
 
           libmesh_assert(side_parent);
 
           new_elem->set_parent(side_parent);
 
           side_parent->set_refinement_flag(Elem::INACTIVE);
 
           // Figuring out which child we are of our parent
           // is a trick.  Due to libMesh child numbering
           // conventions, if we are an element on a vertex,
           // then we share that vertex with our parent, with
           // the same local index.
           bool found_child = false;
           for (unsigned int v=0; v != new_elem->n_vertices(); ++v)
             if (new_elem->node_ptr(v) == side_parent->node_ptr(v))
               {
                 side_parent->add_child(new_elem, v);
                 found_child = true;
               }
 
           // If we don't share any vertex with our parent,
           // then we're the fourth child (index 3) of a
           // triangle.
           if (!found_child)
             {
               libmesh_assert_equal_to (new_elem->n_vertices(), 3);
               side_parent->add_child(new_elem, 3);
             }
         }
 #endif
 
       new_elem->set_interior_parent (const_cast<Elem *>(elem));
 
       // On non-local elements on DistributedMesh we might have
       // RemoteElem neighbor links to construct
       if (!_mesh.is_serial() &&
           (elem->processor_id() != this->processor_id()))
         {
           const unsigned short n_nodes = elem->n_nodes();
 
           const unsigned short bdy_n_sides = new_elem->n_sides();
           const unsigned short bdy_n_nodes = new_elem->n_nodes();
 
           // Check every interior side for a RemoteElem
           for (auto interior_side : elem->side_index_range())
             {
               // Might this interior side have a RemoteElem that
               // needs a corresponding Remote on a boundary side?
               if (elem->neighbor_ptr(interior_side) != remote_elem)
                 continue;
 
               // Which boundary side?
               for (unsigned short boundary_side = 0;
                    boundary_side != bdy_n_sides; ++boundary_side)
                 {
                   // Look for matching node points.  This is safe in
                   // *this* context.
                   bool found_all_nodes = true;
                   for (unsigned short boundary_node = 0;
                        boundary_node != bdy_n_nodes; ++boundary_node)
                     {
                       if (!new_elem->is_node_on_side(boundary_node,
                                                      boundary_side))
                         continue;
 
                       bool found_this_node = false;
                       for (unsigned short interior_node = 0;
                            interior_node != n_nodes; ++interior_node)
                         {
                           if (!elem->is_node_on_side(interior_node,
                                                      interior_side))
                             continue;
 
                           if (new_elem->point(boundary_node) ==
                               elem->point(interior_node))
                             {
                               found_this_node = true;
                               break;
                             }
                         }
                       if (!found_this_node)
                         {
                           found_all_nodes = false;
                           break;
                         }
                     }
 
                   if (found_all_nodes)
                     {
                       new_elem->set_neighbor
                         (boundary_side,
                          const_cast<RemoteElem *>(remote_elem));
                       break;
                     }
                 }
             }
         }
     }
 
   // We haven't been bothering to keep unique ids consistent on ghost
   // elements
   if (!boundary_mesh.is_serial())
     MeshCommunication().make_node_unique_ids_parallel_consistent(boundary_mesh);
 
   // Make sure we didn't add ids inconsistently
 #ifdef DEBUG
 # ifdef LIBMESH_HAVE_RTTI
   DistributedMesh * parmesh = dynamic_cast<DistributedMesh *>(&boundary_mesh);
   if (parmesh)
     parmesh->libmesh_assert_valid_parallel_ids();
 # endif
 #endif
 }

◆ add_node() [1/3]

void libMesh::BoundaryInfo::add_node	(	const Node *	node,
		const boundary_id_type	id
	)

Add Node node with boundary id id to the boundary information data structures.

Definition at line 599 of file boundary_info.C.

References _boundary_ids, _boundary_node_id, _node_boundary_ids, libMesh::as_range(), and invalid_id.

Referenced by libMesh::MeshTools::Subdivision::add_boundary_ghosts(), add_node(), libMesh::AbaqusIO::assign_boundary_node_ids(), libMesh::MeshTools::Generation::build_extrusion(), build_node_list_from_side_list(), libMesh::MeshTools::Modification::change_boundary_id(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::GmshIO::read_mesh(), libMesh::CheckpointIO::read_nodesets(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::ReplicatedMesh::stitching_helper(), sync(), and libMesh::Parallel::Packing< T >::unpack().

 {
   if (id == invalid_id)
     libmesh_error_msg("ERROR: You may not set a boundary ID of "   \
                       << invalid_id                                \
                       << "\n That is reserved for internal use.");
 
   // Don't add the same ID twice
   for (const auto & pr : as_range(_boundary_node_id.equal_range(node)))
     if (pr.second == id)
       return;
 
   _boundary_node_id.insert(std::make_pair(node, id));
   _boundary_ids.insert(id);
   _node_boundary_ids.insert(id); // Also add this ID to the set of node boundary IDs
 }

◆ add_node() [2/3]

void libMesh::BoundaryInfo::add_node	(	const dof_id_type	node,
		const boundary_id_type	id
	)

Add node number node with boundary id id to the boundary information data structures.

Definition at line 584 of file boundary_info.C.

References _mesh, add_node(), and libMesh::MeshBase::query_node_ptr().

 {
   const Node * node_ptr = _mesh.query_node_ptr(node_id);
 
   // The user could easily ask for an invalid node id, so let's throw
   // an easy-to-understand error message when this happens.
   if (!node_ptr)
     libmesh_error_msg("BoundaryInfo::add_node(): Could not retrieve pointer for node " << node_id << ", no boundary id was added.");
 
   this->add_node (node_ptr, id);
 }

◆ add_node() [3/3]

void libMesh::BoundaryInfo::add_node	(	const Node *	node,
		const std::vector< boundary_id_type > &	ids
	)

Add Node node with boundary ids ids to the boundary information data structure.

Definition at line 619 of file boundary_info.C.

References _boundary_ids, _boundary_node_id, _node_boundary_ids, libMesh::as_range(), and invalid_id.

 {
   if (ids.empty())
     return;
 
   libmesh_assert(node);
 
   // Don't add the same ID twice
   auto bounds = _boundary_node_id.equal_range(node);
 
   // The entries in the ids vector may be non-unique.  If we expected
   // *lots* of ids, it might be fastest to construct a std::set from
   // the entries, but for a small number of entries, which is more
   // typical, it is probably faster to copy the vector and do sort+unique.
   // http://stackoverflow.com/questions/1041620/whats-the-most-efficient-way-to-erase-duplicates-and-sort-a-vector
   std::vector<boundary_id_type> unique_ids(ids.begin(), ids.end());
   std::sort(unique_ids.begin(), unique_ids.end());
   std::vector<boundary_id_type>::iterator new_end =
     std::unique(unique_ids.begin(), unique_ids.end());
 
   for (auto & id : as_range(unique_ids.begin(), new_end))
     {
       if (id == invalid_id)
         libmesh_error_msg("ERROR: You may not set a boundary ID of "    \
                           << invalid_id                                 \
                           << "\n That is reserved for internal use.");
 
       bool already_inserted = false;
       for (const auto & pr : as_range(bounds))
         if (pr.second == id)
           {
             already_inserted = true;
             break;
           }
       if (already_inserted)
         continue;
 
       _boundary_node_id.insert(std::make_pair(node,id));
       _boundary_ids.insert(id);
       _node_boundary_ids.insert(id); // Also add this ID to the set of node boundary IDs
     }
 }

◆ add_shellface() [1/3]

void libMesh::BoundaryInfo::add_shellface	(	const dof_id_type	elem,
		const unsigned short int	shellface,
		const boundary_id_type	id
	)

Add shell face shellface of element number elem with boundary id id to the boundary information data structure. This is only relevant for shell elements.

Definition at line 757 of file boundary_info.C.

References _mesh, and libMesh::MeshBase::elem_ptr().

Referenced by libMesh::MeshTools::Modification::change_boundary_id(), copy_boundary_ids(), libMesh::ExodusII_IO::read(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::ReplicatedMesh::stitching_helper(), and libMesh::Parallel::Packing< T >::unpack().

 {
   this->add_shellface (_mesh.elem_ptr(e), shellface, id);
 }

◆ add_shellface() [2/3]

void libMesh::BoundaryInfo::add_shellface	(	const Elem *	elem,
		const unsigned short int	shellface,
		const boundary_id_type	id
	)

Add shell face shellface of element elem with boundary id id to the boundary information data structure. This is only relevant for shell elements.

Definition at line 766 of file boundary_info.C.

References _boundary_ids, _boundary_shellface_id, _shellface_boundary_ids, libMesh::as_range(), invalid_id, and libMesh::Elem::level().

 {
   libmesh_assert(elem);
 
   // Only add BCs for level-0 elements.
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Shells only have 2 faces
   libmesh_assert_less(shellface, 2);
 
   if (id == invalid_id)
     libmesh_error_msg("ERROR: You may not set a boundary ID of "        \
                       << invalid_id                                     \
                       << "\n That is reserved for internal use.");
 
   // Don't add the same ID twice
   for (const auto & pr : as_range(_boundary_shellface_id.equal_range(elem)))
     if (pr.second.first == shellface &&
         pr.second.second == id)
       return;
 
   _boundary_shellface_id.insert(std::make_pair(elem, std::make_pair(shellface, id)));
   _boundary_ids.insert(id);
   _shellface_boundary_ids.insert(id); // Also add this ID to the set of shellface boundary IDs
 }

◆ add_shellface() [3/3]

void libMesh::BoundaryInfo::add_shellface	(	const Elem *	elem,
		const unsigned short int	shellface,
		const std::vector< boundary_id_type > &	ids
	)

Add shell face shellface of element elem with boundary ids ids to the boundary information data structure. This is only relevant for shell elements.

Definition at line 796 of file boundary_info.C.

References _boundary_ids, _boundary_shellface_id, _shellface_boundary_ids, libMesh::as_range(), invalid_id, and libMesh::Elem::level().

 {
   if (ids.empty())
     return;
 
   libmesh_assert(elem);
 
   // Only add BCs for level-0 elements.
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Shells only have 2 faces
   libmesh_assert_less(shellface, 2);
 
   // Don't add the same ID twice
   auto bounds = _boundary_shellface_id.equal_range(elem);
 
   // The entries in the ids vector may be non-unique.  If we expected
   // *lots* of ids, it might be fastest to construct a std::set from
   // the entries, but for a small number of entries, which is more
   // typical, it is probably faster to copy the vector and do sort+unique.
   // http://stackoverflow.com/questions/1041620/whats-the-most-efficient-way-to-erase-duplicates-and-sort-a-vector
   std::vector<boundary_id_type> unique_ids(ids.begin(), ids.end());
   std::sort(unique_ids.begin(), unique_ids.end());
   std::vector<boundary_id_type>::iterator new_end =
     std::unique(unique_ids.begin(), unique_ids.end());
 
   for (auto & id : as_range(unique_ids.begin(), new_end))
     {
       if (id == invalid_id)
         libmesh_error_msg("ERROR: You may not set a boundary ID of "   \
                           << invalid_id                                \
                           << "\n That is reserved for internal use.");
 
       bool already_inserted = false;
       for (const auto & pr : as_range(bounds))
         if (pr.second.first == shellface &&
             pr.second.second == id)
           {
             already_inserted = true;
             break;
           }
       if (already_inserted)
         continue;
 
       _boundary_shellface_id.insert(std::make_pair(elem, std::make_pair(shellface, id)));
       _boundary_ids.insert(id);
       _shellface_boundary_ids.insert(id); // Also add this ID to the set of shellface boundary IDs
     }
 }

◆ add_side() [1/3]

void libMesh::BoundaryInfo::add_side	(	const dof_id_type	elem,
		const unsigned short int	side,
		const boundary_id_type	id
	)

Add side side of element number elem with boundary id id to the boundary information data structure.

Definition at line 849 of file boundary_info.C.

References _mesh, libMesh::MeshBase::elem_ptr(), and side.

Referenced by libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::AbaqusIO::assign_sideset_ids(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_delaunay_square(), libMesh::MeshTools::Generation::build_extrusion(), build_side_list_from_node_list(), libMesh::MeshTools::Modification::change_boundary_id(), copy_boundary_ids(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::flatten(), libMesh::UNVIO::groups_in(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_bcs(), libMesh::GmshIO::read_mesh(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::ReplicatedMesh::stitching_helper(), and libMesh::Parallel::Packing< T >::unpack().

 {
   this->add_side (_mesh.elem_ptr(e), side, id);
 }

◆ add_side() [2/3]

void libMesh::BoundaryInfo::add_side	(	const Elem *	elem,
		const unsigned short int	side,
		const boundary_id_type	id
	)

Add side side of element elem with boundary id id to the boundary information data structure.

Definition at line 858 of file boundary_info.C.

References _boundary_ids, _boundary_side_id, _side_boundary_ids, libMesh::as_range(), invalid_id, libMesh::Elem::level(), and side.

 {
   libmesh_assert(elem);
 
   // Only add BCs for level-0 elements.
   libmesh_assert_equal_to (elem->level(), 0);
 
   if (id == invalid_id)
     libmesh_error_msg("ERROR: You may not set a boundary ID of "        \
                       << invalid_id                                     \
                       << "\n That is reserved for internal use.");
 
   // Don't add the same ID twice
   for (const auto & pr : as_range(_boundary_side_id.equal_range(elem)))
     if (pr.second.first == side &&
         pr.second.second == id)
       return;
 
   _boundary_side_id.insert(std::make_pair(elem, std::make_pair(side, id)));
   _boundary_ids.insert(id);
   _side_boundary_ids.insert(id); // Also add this ID to the set of side boundary IDs
 }

◆ add_side() [3/3]

void libMesh::BoundaryInfo::add_side	(	const Elem *	elem,
		const unsigned short int	side,
		const std::vector< boundary_id_type > &	ids
	)

Add side side of element elem with boundary ids ids to the boundary information data structure.

Definition at line 885 of file boundary_info.C.

References _boundary_ids, _boundary_side_id, _side_boundary_ids, libMesh::as_range(), invalid_id, libMesh::Elem::level(), and side.

 {
   if (ids.empty())
     return;
 
   libmesh_assert(elem);
 
   // Only add BCs for level-0 elements.
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Don't add the same ID twice
   auto bounds = _boundary_side_id.equal_range(elem);
 
   // The entries in the ids vector may be non-unique.  If we expected
   // *lots* of ids, it might be fastest to construct a std::set from
   // the entries, but for a small number of entries, which is more
   // typical, it is probably faster to copy the vector and do sort+unique.
   // http://stackoverflow.com/questions/1041620/whats-the-most-efficient-way-to-erase-duplicates-and-sort-a-vector
   std::vector<boundary_id_type> unique_ids(ids.begin(), ids.end());
   std::sort(unique_ids.begin(), unique_ids.end());
   std::vector<boundary_id_type>::iterator new_end =
     std::unique(unique_ids.begin(), unique_ids.end());
 
   for (auto & id : as_range(unique_ids.begin(), new_end))
     {
       if (id == invalid_id)
         libmesh_error_msg("ERROR: You may not set a boundary ID of "    \
                           << invalid_id                                 \
                           << "\n That is reserved for internal use.");
 
       bool already_inserted = false;
       for (const auto & pr : as_range(bounds))
         if (pr.second.first == side && pr.second.second == id)
           {
             already_inserted = true;
             break;
           }
       if (already_inserted)
         continue;
 
       _boundary_side_id.insert(std::make_pair(elem, std::make_pair(side, id)));
       _boundary_ids.insert(id);
       _side_boundary_ids.insert(id); // Also add this ID to the set of side boundary IDs
     }
 }

◆ boundary_id()

boundary_id_type libMesh::BoundaryInfo::boundary_id	(	const Elem *const	elem,
		const unsigned short int	side
	)		const

Returns: The boundary id associated with the side side of element elem, or invalid_id if the side does not have an associated boundary id.

Note: Only one id per side is allowed, however multiple sides per element are allowed.

Deprecated:: Asking for just one boundary id means your code isn't safe to use on meshes with overlapping boundary ids. Try using BoundaryInfo::boundary_ids() or BoundaryInfo::has_boundary_id() instead.

Definition at line 1164 of file boundary_info.C.

References boundary_ids(), invalid_id, and side.

 {
   libmesh_deprecated();
 
   std::vector<boundary_id_type> ids;
   this->boundary_ids(elem, side, ids);
 
   // If the set is empty, return invalid_id
   if (ids.empty())
     return invalid_id;
 
   // Otherwise, just return the first id we came across for this
   // element on this side.
   return *(ids.begin());
 }

◆ boundary_ids() [1/4]

std::vector< boundary_id_type > libMesh::BoundaryInfo::boundary_ids ( const Node * node ) const

Returns: The boundary ids associated with Node node.

Deprecated:: Instead, use the version of this function that fills a std::vector.

Definition at line 948 of file boundary_info.C.

Referenced by libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), boundary_id(), boundary_ids(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_extrusion(), build_node_list_from_side_list(), libMesh::MeshTools::Modification::change_boundary_id(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::flatten(), has_boundary_id(), n_boundary_ids(), libMesh::BoundaryProjectSolution::operator()(), libMesh::Parallel::Packing< T >::pack(), libMesh::FEMContext::side_boundary_ids(), libMesh::ReplicatedMesh::stitching_helper(), sync(), libMesh::XdrIO::write_serialized_bcs_helper(), and libMesh::XdrIO::write_serialized_nodesets().

 {
   libmesh_deprecated();
 
   std::vector<boundary_id_type> ids;
   this->boundary_ids(node, ids);
   return ids;
 }

◆ boundary_ids() [2/4]

void libMesh::BoundaryInfo::boundary_ids	(	const Node *	node,
		std::vector< boundary_id_type > &	vec_to_fill
	)		const

Fills a user-provided std::vector with the boundary ids associated with Node node.

This is the non-deprecated version of the function.

Definition at line 960 of file boundary_info.C.

References _boundary_node_id, and libMesh::as_range().

 {
   // Clear out any previous contents
   vec_to_fill.clear();
 
   for (const auto & pr : as_range(_boundary_node_id.equal_range(node)))
     vec_to_fill.push_back(pr.second);
 }

◆ boundary_ids() [3/4]

std::vector< boundary_id_type > libMesh::BoundaryInfo::boundary_ids	(	const Elem *const	elem,
		const unsigned short int	side
	)		const

Returns: The list of boundary ids associated with the side side of element elem.

Deprecated:: Instead, use the version of this function that fills a std::vector.

Definition at line 1196 of file boundary_info.C.

References boundary_ids(), and side.

 {
   libmesh_deprecated();
 
   std::vector<boundary_id_type> ids;
   this->boundary_ids(elem, side, ids);
   return ids;
 }

◆ boundary_ids() [4/4]

void libMesh::BoundaryInfo::boundary_ids	(	const Elem *const	elem,
		const unsigned short int	side,
		std::vector< boundary_id_type > &	vec_to_fill
	)		const

Returns: The list of boundary ids associated with the side side of element elem.

This is the non-deprecated version of the function.

Definition at line 1209 of file boundary_info.C.

References _boundary_side_id, libMesh::as_range(), libMesh::Elem::is_child_on_side(), libMesh::Elem::level(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::parent(), side, libMesh::Elem::top_parent(), and libMesh::Elem::which_child_am_i().

 {
   libmesh_assert(elem);
 
   // Clear out any previous contents
   vec_to_fill.clear();
 
   // Only level-0 elements store BCs.  If this is not a level-0
   // element get its level-0 parent and infer the BCs.
   const Elem * searched_elem = elem;
   if (elem->level() != 0)
     {
       if (elem->neighbor_ptr(side) == nullptr)
         searched_elem = elem->top_parent ();
 #ifdef LIBMESH_ENABLE_AMR
       else
         while (searched_elem->parent() != nullptr)
           {
             const Elem * parent = searched_elem->parent();
             if (parent->is_child_on_side(parent->which_child_am_i(searched_elem), side) == false)
               return;
             searched_elem = parent;
           }
 #endif
     }
 
   // Check each element in the range to see if its side matches the requested side.
   for (const auto & pr : as_range(_boundary_side_id.equal_range(searched_elem)))
     if (pr.second.first == side)
       vec_to_fill.push_back(pr.second.second);
 }

◆ build_active_side_list() [1/2]

void libMesh::BoundaryInfo::build_active_side_list	(	std::vector< dof_id_type > &	element_id_list,
		std::vector< unsigned short int > &	side_list,
		std::vector< boundary_id_type > &	bc_id_list
	)		const

Creates a list of active element numbers, sides, and ids for those sides.

On a ReplicatedMesh this will include all sides; on a DistributedMesh only sides of semilocal elements will be included.

Deprecated:: Use the version of build_active_side_list() below that returns a std::vector of tuples instead.

Definition at line 2058 of file boundary_info.C.

References build_active_side_list().

 {
   libmesh_deprecated();
 
   // Call the non-deprecated version of this function.
   auto bc_tuples = this->build_active_side_list();
 
   // Clear the input vectors, just in case they were used for
   // something else recently...
   el.clear();
   sl.clear();
   il.clear();
 
   // Reserve the size, then use push_back
   el.reserve (bc_tuples.size());
   sl.reserve (bc_tuples.size());
   il.reserve (bc_tuples.size());
 
   for (const auto & t : bc_tuples)
     {
       el.push_back(std::get<0>(t));
       sl.push_back(std::get<1>(t));
       il.push_back(std::get<2>(t));
     }
 }

◆ build_active_side_list() [2/2]

std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > > libMesh::BoundaryInfo::build_active_side_list ( ) const

As above, but the library creates and fills in a vector of (elem-id, side-id, bc-id) triplets and returns it to the user, taking advantage of guaranteed RVO.

Definition at line 2089 of file boundary_info.C.

References _boundary_side_id.

Referenced by build_active_side_list().

 {
   std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> bc_triples;
   bc_triples.reserve(_boundary_side_id.size());
 
   for (const auto & pr : _boundary_side_id)
     {
       // Don't add remote sides
       if (pr.first->is_remote())
         continue;
 
       // Loop over the sides of possible children
       std::vector<const Elem *> family;
 #ifdef LIBMESH_ENABLE_AMR
       pr.first->active_family_tree_by_side(family, pr.second.first);
 #else
       family.push_back(pr.first);
 #endif
 
       // Populate the list items
       for (const auto & elem : family)
         bc_triples.emplace_back(elem->id(), pr.second.first, pr.second.second);
     }
 
   // This list is currently in memory address (arbitrary) order, so
   // sort to make it consistent on all procs.
   std::sort(bc_triples.begin(), bc_triples.end());
 
   return bc_triples;
 }

◆ build_edge_list() [1/2]

void libMesh::BoundaryInfo::build_edge_list	(	std::vector< dof_id_type > &	element_id_list,
		std::vector< unsigned short int > &	edge_list,
		std::vector< boundary_id_type > &	bc_id_list
	)		const

Creates a list of element numbers, edges, and boundary ids for those edges.

On a ReplicatedMesh this will include all edges; on a DistributedMesh only edges of semilocal elements will be included.

Deprecated:: Use the version of build_edge_list() below that returns a std::vector of tuples instead.

Definition at line 2122 of file boundary_info.C.

References build_edge_list().

Referenced by libMesh::MeshTools::Modification::change_boundary_id(), and libMesh::ReplicatedMesh::stitching_helper().

 {
   libmesh_deprecated();
 
   // Call the non-deprecated version of this function.
   auto bc_tuples = this->build_edge_list();
 
   // Clear the input vectors, just in case they were used for
   // something else recently...
   el.clear();
   sl.clear();
   il.clear();
 
   // Reserve the size, then use push_back
   el.reserve (bc_tuples.size());
   sl.reserve (bc_tuples.size());
   il.reserve (bc_tuples.size());
 
   for (const auto & t : bc_tuples)
     {
       el.push_back(std::get<0>(t));
       sl.push_back(std::get<1>(t));
       il.push_back(std::get<2>(t));
     }
 }

◆ build_edge_list() [2/2]

std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > > libMesh::BoundaryInfo::build_edge_list ( ) const

As above, but the library creates and fills in a vector of (elem-id, side-id, bc-id) triplets and returns it to the user, taking advantage of guaranteed RVO.

Definition at line 2153 of file boundary_info.C.

References _boundary_edge_id.

Referenced by build_edge_list().

 {
   std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> bc_triples;
   bc_triples.reserve(_boundary_edge_id.size());
 
   for (const auto & pr : _boundary_edge_id)
     bc_triples.emplace_back(pr.first->id(), pr.second.first, pr.second.second);
 
   // This list is currently in memory address (arbitrary) order, so
   // sort to make it consistent on all procs.
   std::sort(bc_triples.begin(), bc_triples.end());
 
   return bc_triples;
 }

◆ build_node_boundary_ids()

void libMesh::BoundaryInfo::build_node_boundary_ids ( std::vector< boundary_id_type > & b_ids ) const

Builds the list of unique node boundary ids.

On a ReplicatedMesh this will be all ids; on a DistributedMesh only ids on semilocal nodes will be included.

Definition at line 1605 of file boundary_info.C.

References _boundary_node_id.

Referenced by libMesh::ExodusII_IO_Helper::initialize(), and libMesh::ExodusII_IO_Helper::write_nodesets().

 {
   b_ids.clear();
 
   for (const auto & pr : _boundary_node_id)
     {
       boundary_id_type id = pr.second;
 
       if (std::find(b_ids.begin(),b_ids.end(),id) == b_ids.end())
         b_ids.push_back(id);
     }
 }

◆ build_node_list() [1/2]

void libMesh::BoundaryInfo::build_node_list	(	std::vector< dof_id_type > &	node_id_list,
		std::vector< boundary_id_type > &	bc_id_list
	)		const

Creates a list of nodes and ids for those nodes.

On a ReplicatedMesh this will include all nodes; on a DistributedMesh only semilocal nodes will be included.

Deprecated:: Use the version of build_node_list() below that returns a std::vector of tuples instead.

Definition at line 1735 of file boundary_info.C.

References build_node_list().

Referenced by libMesh::MeshTools::Modification::change_boundary_id(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::ReplicatedMesh::stitching_helper(), libMesh::CheckpointIO::write(), and libMesh::ExodusII_IO_Helper::write_nodesets().

 {
   libmesh_deprecated();
 
   // Call the non-deprecated version of this function.
   auto bc_tuples = this->build_node_list();
 
   // Clear the input vectors, just in case they were used for
   // something else recently...
   nl.clear();
   il.clear();
 
   // Reserve the size, then use push_back
   nl.reserve (bc_tuples.size());
   il.reserve (bc_tuples.size());
 
   for (const auto & t : bc_tuples)
     {
       nl.push_back(std::get<0>(t));
       il.push_back(std::get<1>(t));
     }
 }

◆ build_node_list() [2/2]

std::vector< std::tuple< dof_id_type, boundary_id_type > > libMesh::BoundaryInfo::build_node_list ( ) const

As above, but the library creates and fills in a vector of (node-id, bc-id) pairs and returns it to the user, taking advantage of guaranteed RVO. Note: we could use std::pairs for this, but for consistency with the other build_XYZ_list functions, we're using tuples.

Definition at line 1762 of file boundary_info.C.

References _boundary_node_id.

Referenced by build_node_list().

 {
   std::vector<std::tuple<dof_id_type, boundary_id_type>> bc_tuples;
   bc_tuples.reserve(_boundary_node_id.size());
 
   for (const auto & pr : _boundary_node_id)
     bc_tuples.emplace_back(pr.first->id(), pr.second);
 
   // This list is currently in memory address (arbitrary) order, so
   // sort to make it consistent on all procs.
   std::sort(bc_tuples.begin(), bc_tuples.end());
 
   return bc_tuples;
 }

◆ build_node_list_from_side_list()

void libMesh::BoundaryInfo::build_node_list_from_side_list ( )

Adds nodes with boundary ids based on the side's boundary ids they are connected to.

Definition at line 1779 of file boundary_info.C.

References _boundary_side_id, _mesh, add_node(), libMesh::Parallel::any_source, boundary_ids(), libMesh::ParallelObject::comm(), libMesh::Parallel::Communicator::get_unique_tag(), libMesh::MeshBase::is_serial(), libMesh::ParallelObject::n_processors(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::node_ptr_range(), libMesh::ParallelObject::processor_id(), libMesh::Parallel::Communicator::receive(), libMesh::Parallel::Communicator::send(), side, and libMesh::Parallel::wait().

 {
   // If we're on a distributed mesh, even the owner of a node is not
   // guaranteed to be able to properly assign its new boundary id(s)!
   // Nodal neighbors are not always ghosted, and a nodal neighbor
   // might have a boundary side.
   const bool mesh_is_serial = _mesh.is_serial();
 
   typedef std::set<std::pair<dof_id_type, boundary_id_type>> set_type;
 
   const processor_id_type n_proc     = this->n_processors();
   const processor_id_type my_proc_id = this->processor_id();
   std::vector<set_type> nodes_to_push(n_proc);
 
   // Pull objects out of the loop to reduce heap operations
   std::unique_ptr<const Elem> side;
 
   // Loop over the side list
   for (const auto & pr : _boundary_side_id)
     {
       // Don't add remote sides
       if (pr.first->is_remote())
         continue;
 
       // Need to loop over the sides of any possible children
       std::vector<const Elem *> family;
 #ifdef LIBMESH_ENABLE_AMR
       pr.first->active_family_tree_by_side (family, pr.second.first);
 #else
       family.push_back(pr.first);
 #endif
 
       for (const auto & cur_elem : family)
         {
           cur_elem->build_side_ptr(side, pr.second.first);
 
           // Add each node node on the side with the side's boundary id
           for (auto i : side->node_index_range())
             {
               const boundary_id_type bcid = pr.second.second;
               this->add_node(side->node_ptr(i), bcid);
               if (!mesh_is_serial)
                 {
                   const processor_id_type proc_id =
                     side->node_ptr(i)->processor_id();
                   if (proc_id != my_proc_id)
                     nodes_to_push[proc_id].insert
                       (std::make_pair(side->node_id(i), bcid));
                 }
             }
         }
     }
 
   // If we're on a serial mesh then we're done.
   if (mesh_is_serial)
     return;
 
   // Otherwise we need to push ghost node bcids to their owners, then
   // pull ghost node bcids from their owners.
   Parallel::MessageTag
     node_pushes_tag = this->comm().get_unique_tag(31337),
     node_pulls_tag = this->comm().get_unique_tag(31338),
     node_responses_tag = this->comm().get_unique_tag(31339);
 
   std::vector<Parallel::Request> node_push_requests(n_proc-1);
 
   for (processor_id_type p = 0; p != n_proc; ++p)
     {
       if (p == my_proc_id)
         continue;
 
       Parallel::Request &request =
         node_push_requests[p - (p > my_proc_id)];
 
       this->comm().send
         (p, nodes_to_push[p], request, node_pushes_tag);
     }
 
   for (processor_id_type p = 1; p != n_proc; ++p)
     {
       set_type received_nodes;
 
       this->comm().receive
         (Parallel::any_source, received_nodes, node_pushes_tag);
 
       for (const auto & pr : received_nodes)
         this->add_node(_mesh.node_ptr(pr.first), pr.second);
     }
 
   // At this point we should know all the BCs for our own nodes; now
   // we need BCs for ghost nodes.
   //
   // FIXME - parallel_ghost_sync.h doesn't work here because it
   // assumes a fixed size datum on each node.
   std::vector<std::vector<dof_id_type>> node_ids_requested(n_proc);
 
   // Determine what nodes we need to request
   for (const auto & node : _mesh.node_ptr_range())
     {
       const processor_id_type pid = node->processor_id();
       if (pid != my_proc_id)
         node_ids_requested[pid].push_back(node->id());
     }
 
   typedef std::vector<std::pair<dof_id_type, boundary_id_type>> vec_type;
 
   std::vector<Parallel::Request>
     node_pull_requests(n_proc-1),
     node_response_requests(n_proc-1);
 
   // Make all requests
   for (processor_id_type p = 0; p != n_proc; ++p)
     {
       if (p == my_proc_id)
         continue;
 
       Parallel::Request &request =
         node_pull_requests[p - (p > my_proc_id)];
 
       this->comm().send
         (p, node_ids_requested[p], request, node_pulls_tag);
     }
 
   // Process all incoming requests
   std::vector<vec_type> responses(n_proc-1);
 
   for (processor_id_type p = 1; p != n_proc; ++p)
     {
       std::vector<dof_id_type> requested_nodes;
 
       Parallel::Status
         status(this->comm().probe (Parallel::any_source, node_pulls_tag));
       const processor_id_type
         source_pid = cast_int<processor_id_type>(status.source());
 
       this->comm().receive
         (source_pid, requested_nodes, node_pulls_tag);
 
       Parallel::Request &request =
         node_response_requests[p-1];
 
       std::vector<boundary_id_type> bcids;
 
       for (const auto & id : requested_nodes)
         {
           this->boundary_ids(_mesh.node_ptr(id), bcids);
 
           for (const auto & b : bcids)
             responses[p-1].push_back(std::make_pair(id, b));
         }
 
       this->comm().send
         (source_pid, responses[p-1], request, node_responses_tag);
     }
 
   // Process all incoming responses
   for (processor_id_type p = 1; p != n_proc; ++p)
     {
       Parallel::Status
         status(this->comm().probe (Parallel::any_source, node_responses_tag));
       const processor_id_type
         source_pid = cast_int<processor_id_type>(status.source());
 
       vec_type response;
 
       this->comm().receive
         (source_pid, response, node_responses_tag);
 
       for (const auto & pr : response)
         this->add_node(_mesh.node_ptr(pr.first), pr.second);
     }
 
   Parallel::wait (node_push_requests);
   Parallel::wait (node_pull_requests);
   Parallel::wait (node_response_requests);
 }

◆ build_shellface_boundary_ids()

void libMesh::BoundaryInfo::build_shellface_boundary_ids ( std::vector< boundary_id_type > & b_ids ) const

Builds the list of unique shellface boundary ids.

On a ReplicatedMesh this will be all ids; on a DistributedMesh only ids on shellfaces of semilocal elements will be included.

Definition at line 1633 of file boundary_info.C.

References _boundary_shellface_id.

Referenced by libMesh::ExodusII_IO_Helper::initialize(), and libMesh::ExodusII_IO_Helper::write_sidesets().

 {
   b_ids.clear();
 
   for (const auto & pr :_boundary_shellface_id)
     {
       boundary_id_type id = pr.second.second;
 
       if (std::find(b_ids.begin(),b_ids.end(),id) == b_ids.end())
         b_ids.push_back(id);
     }
 }

◆ build_shellface_list() [1/2]

void libMesh::BoundaryInfo::build_shellface_list	(	std::vector< dof_id_type > &	element_id_list,
		std::vector< unsigned short int > &	shellface_list,
		std::vector< boundary_id_type > &	bc_id_list
	)		const

Creates a list of element numbers, shellfaces, and boundary ids for those shellfaces.

On a ReplicatedMesh this will include all shellfaces; on a DistributedMesh only shellfaces of semilocal elements will be included.

Deprecated:: Use the version of build_shellface_list() below that returns a std::vector of tuples instead.

Definition at line 2170 of file boundary_info.C.

References build_shellface_list().

Referenced by libMesh::MeshTools::Modification::change_boundary_id(), libMesh::ReplicatedMesh::stitching_helper(), and libMesh::ExodusII_IO_Helper::write_sidesets().

 {
   libmesh_deprecated();
 
   // Call the non-deprecated version of this function.
   auto bc_tuples = this->build_shellface_list();
 
   // Clear the input vectors, just in case they were used for
   // something else recently...
   el.clear();
   sl.clear();
   il.clear();
 
   // Reserve the size, then use push_back
   el.reserve (bc_tuples.size());
   sl.reserve (bc_tuples.size());
   il.reserve (bc_tuples.size());
 
   for (const auto & t : bc_tuples)
     {
       el.push_back(std::get<0>(t));
       sl.push_back(std::get<1>(t));
       il.push_back(std::get<2>(t));
     }
 }

◆ build_shellface_list() [2/2]

std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > > libMesh::BoundaryInfo::build_shellface_list ( ) const

As above, but the library creates and fills in a vector of (elem-id, side-id, bc-id) triplets and returns it to the user, taking advantage of guaranteed RVO.

Definition at line 2201 of file boundary_info.C.

References _boundary_shellface_id.

Referenced by build_shellface_list().

 {
   std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> bc_triples;
   bc_triples.reserve(_boundary_shellface_id.size());
 
   for (const auto & pr : _boundary_shellface_id)
     bc_triples.emplace_back(pr.first->id(), pr.second.first, pr.second.second);
 
   // This list is currently in memory address (arbitrary) order, so
   // sort to make it consistent on all procs.
   std::sort(bc_triples.begin(), bc_triples.end());
 
   return bc_triples;
 }

◆ build_side_boundary_ids()

void libMesh::BoundaryInfo::build_side_boundary_ids ( std::vector< boundary_id_type > & b_ids ) const

Builds the list of unique side boundary ids.

On a ReplicatedMesh this will be all ids; on a DistributedMesh only ids on sides of semilocal elements will be included.

Definition at line 1619 of file boundary_info.C.

References _boundary_side_id.

Referenced by libMesh::ExodusII_IO_Helper::initialize(), and libMesh::ExodusII_IO_Helper::write_sidesets().

 {
   b_ids.clear();
 
   for (const auto & pr : _boundary_side_id)
     {
       boundary_id_type id = pr.second.second;
 
       if (std::find(b_ids.begin(),b_ids.end(),id) == b_ids.end())
         b_ids.push_back(id);
     }
 }

◆ build_side_list() [1/2]

void libMesh::BoundaryInfo::build_side_list	(	std::vector< dof_id_type > &	element_id_list,
		std::vector< unsigned short int > &	side_list,
		std::vector< boundary_id_type > &	bc_id_list
	)		const

Creates a list of element numbers, sides, and ids for those sides.

On a ReplicatedMesh this will include all sides; on a DistributedMesh only sides of semilocal elements will be included.

Deprecated:: Use the version of build_side_list() below that returns a std::vector of tuples instead.

Definition at line 2007 of file boundary_info.C.

References build_side_list().

Referenced by libMesh::MeshTools::Modification::change_boundary_id(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::ReplicatedMesh::stitching_helper(), libMesh::FroIO::write(), libMesh::CheckpointIO::write(), libMesh::GmshIO::write_mesh(), and libMesh::ExodusII_IO_Helper::write_sidesets().

 {
   libmesh_deprecated();
 
   // Call the non-deprecated version of this function.
   auto bc_tuples = this->build_side_list();
 
   // Clear the input vectors, just in case they were used for
   // something else recently...
   el.clear();
   sl.clear();
   il.clear();
 
   // Reserve the size, then use push_back
   el.reserve (bc_tuples.size());
   sl.reserve (bc_tuples.size());
   il.reserve (bc_tuples.size());
 
   for (const auto & t : bc_tuples)
     {
       el.push_back(std::get<0>(t));
       sl.push_back(std::get<1>(t));
       il.push_back(std::get<2>(t));
     }
 }

◆ build_side_list() [2/2]

std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > > libMesh::BoundaryInfo::build_side_list ( ) const

As above, but the library creates and fills in a vector of (elem-id, side-id, bc-id) triplets and returns it to the user, taking advantage of guaranteed RVO.

Definition at line 2038 of file boundary_info.C.

References _boundary_side_id.

Referenced by build_side_list().

 {
   std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> bc_triples;
   bc_triples.reserve(_boundary_side_id.size());
 
   for (const auto & pr : _boundary_side_id)
     bc_triples.emplace_back(pr.first->id(), pr.second.first, pr.second.second);
 
   // bc_triples is currently in whatever order the Elem pointers in
   // the _boundary_side_id multimap are in, and in particular might be
   // in different orders on different processors. To avoid this
   // inconsistency, we'll sort using the default operator< for tuples.
   std::sort(bc_triples.begin(), bc_triples.end());
 
   return bc_triples;
 }

◆ build_side_list_from_node_list()

void libMesh::BoundaryInfo::build_side_list_from_node_list ( )

Adds sides to a sideset if every node on that side are in the same sideset

Definition at line 1959 of file boundary_info.C.

References _boundary_node_id, _mesh, libMesh::MeshBase::active_element_ptr_range(), add_side(), libMesh::as_range(), nodeset_name(), libMesh::out, side, and sideset_name().

Referenced by libMesh::AbaqusIO::read().

 {
   // Check for early return
   if (_boundary_node_id.empty())
     {
       libMesh::out << "No boundary node IDs have been added: cannot build side list!" << std::endl;
       return;
     }
 
   // Pull objects out of the loop to reduce heap operations
   std::unique_ptr<const Elem> side_elem;
 
   for (const auto & elem : _mesh.active_element_ptr_range())
     for (auto side : elem->side_index_range())
       {
         elem->build_side_ptr(side_elem, side);
 
         // map from nodeset_id to count for that ID
         std::map<boundary_id_type, unsigned> nodesets_node_count;
 
         // For each nodeset that this node is a member of, increment the associated
         // nodeset ID count
         for (const auto & node : side_elem->node_ref_range())
           for (const auto & pr : as_range(_boundary_node_id.equal_range(&node)))
             nodesets_node_count[pr.second]++;
 
         // Now check to see what nodeset_counts have the correct
         // number of nodes in them.  For any that do, add this side to
         // the sideset, making sure the sideset inherits the
         // nodeset's name, if there is one.
         for (const auto & pr : nodesets_node_count)
           if (pr.second == side_elem->n_nodes())
             {
               add_side(elem, side, pr.first);
 
               // Let the sideset inherit any non-empty name from the nodeset
               std::string & nset_name = nodeset_name(pr.first);
 
               if (nset_name != "")
                 sideset_name(pr.first) = nset_name;
             }
       } // end for side
 }

◆ clear()

void libMesh::BoundaryInfo::clear ( )

Clears the underlying data structures and restores the object to a pristine state with no data stored.

Definition at line 107 of file boundary_info.C.

References _boundary_edge_id, _boundary_ids, _boundary_node_id, _boundary_shellface_id, _boundary_side_id, _edge_boundary_ids, _node_boundary_ids, _shellface_boundary_ids, and _side_boundary_ids.

Referenced by operator=(), and ~BoundaryInfo().

 {
   _boundary_node_id.clear();
   _boundary_side_id.clear();
   _boundary_edge_id.clear();
   _boundary_shellface_id.clear();
   _boundary_ids.clear();
   _side_boundary_ids.clear();
   _node_boundary_ids.clear();
   _edge_boundary_ids.clear();
   _shellface_boundary_ids.clear();
 }

◆ clear_boundary_node_ids()

void libMesh::BoundaryInfo::clear_boundary_node_ids ( )

Clears all the boundary information from all of the nodes in the mesh

Definition at line 665 of file boundary_info.C.

References _boundary_node_id.

 {
   _boundary_node_id.clear();
 }

◆ comm()

const Parallel::Communicator& libMesh::ParallelObject::comm ( ) const

inlineinherited

Returns: A reference to the Parallel::Communicator object used by this mesh.

Definition at line 89 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

90 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

◆ copy_boundary_ids()

void libMesh::BoundaryInfo::copy_boundary_ids	(	const BoundaryInfo &	old_boundary_info,
		const Elem *const	old_elem,
		const Elem *const	new_elem
	)

Definition at line 1291 of file boundary_info.C.

References add_edge(), add_shellface(), add_side(), libMesh::Elem::edge_index_range(), libMesh::Elem::n_edges(), libMesh::Elem::n_sides(), raw_boundary_ids(), raw_edge_boundary_ids(), raw_shellface_boundary_ids(), and libMesh::Elem::side_index_range().

Referenced by libMesh::UnstructuredMesh::all_first_order(), and libMesh::UnstructuredMesh::all_second_order().

 {
   libmesh_assert_equal_to (old_elem->n_sides(), new_elem->n_sides());
   libmesh_assert_equal_to (old_elem->n_edges(), new_elem->n_edges());
 
   std::vector<boundary_id_type> bndry_ids;
 
   for (auto s : old_elem->side_index_range())
     {
       old_boundary_info.raw_boundary_ids (old_elem, s, bndry_ids);
       this->add_side (new_elem, s, bndry_ids);
     }
 
   for (auto e : old_elem->edge_index_range())
     {
       old_boundary_info.raw_edge_boundary_ids (old_elem, e, bndry_ids);
       this->add_edge (new_elem, e, bndry_ids);
     }
 
   for (unsigned short sf=0; sf != 2; sf++)
     {
       old_boundary_info.raw_shellface_boundary_ids (old_elem, sf, bndry_ids);
       this->add_shellface (new_elem, sf, bndry_ids);
     }
 }

◆ edge_boundary_ids() [1/2]

std::vector< boundary_id_type > libMesh::BoundaryInfo::edge_boundary_ids	(	const Elem *const	elem,
		const unsigned short int	edge
	)		const

Returns: The list of boundary ids associated with the edge edge of element elem.

Note: Edge-based boundary IDs should only be used in 3D.

Deprecated:: Instead, use the version of this function that fills a std::vector.

Definition at line 981 of file boundary_info.C.

Referenced by libMesh::MeshTools::Modification::change_boundary_id(), n_edge_boundary_ids(), libMesh::BoundaryProjectSolution::operator()(), libMesh::Parallel::Packing< T >::pack(), libMesh::ReplicatedMesh::stitching_helper(), and libMesh::XdrIO::write_serialized_bcs_helper().

 {
   libmesh_deprecated();
 
   std::vector<boundary_id_type> ids;
   this->edge_boundary_ids(elem, edge, ids);
   return ids;
 }

◆ edge_boundary_ids() [2/2]

void libMesh::BoundaryInfo::edge_boundary_ids	(	const Elem *const	elem,
		const unsigned short int	edge,
		std::vector< boundary_id_type > &	vec_to_fill
	)		const

Returns: The list of boundary ids associated with the edge edge of element elem.

Note: Edge-based boundary IDs should only be used in 3D.

This is the non-deprecated version of the function.

Definition at line 994 of file boundary_info.C.

References _boundary_edge_id, libMesh::as_range(), libMesh::Elem::is_child_on_edge(), libMesh::Elem::is_edge_on_side(), libMesh::Elem::level(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::parent(), side, libMesh::Elem::side_index_range(), libMesh::Elem::top_parent(), and libMesh::Elem::which_child_am_i().

 {
   libmesh_assert(elem);
 
   // Clear out any previous contents
   vec_to_fill.clear();
 
   // Only level-0 elements store BCs.  If this is not a level-0
   // element get its level-0 parent and infer the BCs.
   const Elem * searched_elem = elem;
 #ifdef LIBMESH_ENABLE_AMR
   if (elem->level() != 0)
     {
       // Find all the sides that contain edge. If one of those is a boundary
       // side, then this must be a boundary edge. In that case, we just use the
       // top-level parent.
       bool found_boundary_edge = false;
       for (auto side : elem->side_index_range())
         {
           if (elem->is_edge_on_side(edge,side))
             {
               if (elem->neighbor_ptr(side) == nullptr)
                 {
                   searched_elem = elem->top_parent ();
                   found_boundary_edge = true;
                   break;
                 }
             }
         }
 
       if (!found_boundary_edge)
         {
           // Child element is not on external edge, but it may have internal
           // "boundary" IDs.  We will walk up the tree, at each level checking that
           // the current child is actually on the same edge of the parent that is
           // currently being searched for (i.e. that was passed in as "edge").
           while (searched_elem->parent() != nullptr)
             {
               const Elem * parent = searched_elem->parent();
               if (parent->is_child_on_edge(parent->which_child_am_i(searched_elem), edge) == false)
                 return;
               searched_elem = parent;
             }
         }
     }
 #endif
 
   // Check each element in the range to see if its edge matches the requested edge.
   for (const auto & pr : as_range(_boundary_edge_id.equal_range(searched_elem)))
     if (pr.second.first == edge)
       vec_to_fill.push_back(pr.second.second);
 }

◆ get_boundary_ids()

const std::set<boundary_id_type>& libMesh::BoundaryInfo::get_boundary_ids ( ) const

inline

Returns: A set of the boundary ids which exist on semilocal parts of the mesh.

DistributedMesh-compatible code may need a set_union or other manipulations to work with sets of boundary ids which include ids on remote parts of the mesh.

Definition at line 781 of file boundary_info.h.

References _boundary_ids.

Referenced by libMesh::DofMap::check_dirichlet_bcid_consistency(), and libMesh::FroIO::write().

782 { return _boundary_ids; }

libMesh::BoundaryInfo::_boundary_ids

std::set< boundary_id_type > _boundary_ids

Definition: boundary_info.h:935

◆ get_edge_boundary_ids()

const std::set<boundary_id_type>& libMesh::BoundaryInfo::get_edge_boundary_ids ( ) const

inline

Returns: A reference to the set of all boundary IDs specified on edges of semilocal mesh elements.

Note: Edge-based boundary IDs should only be used in 3D.

Definition at line 797 of file boundary_info.h.

References _edge_boundary_ids.

798 { return _edge_boundary_ids; }

libMesh::BoundaryInfo::_edge_boundary_ids

std::set< boundary_id_type > _edge_boundary_ids

Definition: boundary_info.h:953

◆ get_id_by_name()

boundary_id_type libMesh::BoundaryInfo::get_id_by_name ( const std::string & name ) const

Returns: The id of the named boundary if it exists, invalid_id otherwise.

Definition at line 2393 of file boundary_info.C.

References _ns_id_to_name, _ss_id_to_name, invalid_id, and libMesh::Quality::name().

 {
   // Search sidesets
   for (const auto & pr : _ss_id_to_name)
     if (pr.second == name)
       return pr.first;
 
   // Search nodesets
   for (const auto & pr : _ns_id_to_name)
     if (pr.second == name)
       return pr.first;
 
   // If we made it here without returning, we don't have a sideset or
   // nodeset by the requested name, so return invalid_id
   return invalid_id;
 }

◆ get_node_boundary_ids()

const std::set<boundary_id_type>& libMesh::BoundaryInfo::get_node_boundary_ids ( ) const

inline

Returns: A reference to the set of all boundary IDs specified on semilocal mesh nodes.

Definition at line 813 of file boundary_info.h.

References _node_boundary_ids.

Referenced by libMesh::Nemesis_IO_Helper::compute_num_global_nodesets().

814 { return _node_boundary_ids; }

libMesh::BoundaryInfo::_node_boundary_ids

std::set< boundary_id_type > _node_boundary_ids

Definition: boundary_info.h:962

◆ get_nodeset_name()

const std::string & libMesh::BoundaryInfo::get_nodeset_name ( boundary_id_type id ) const

Returns: A reference for getting an optional name for a nodeset.

Definition at line 2377 of file boundary_info.C.

References _ns_id_to_name.

Referenced by libMesh::ExodusII_IO_Helper::write_nodesets().

 {
   static const std::string empty_string;
   std::map<boundary_id_type, std::string>::const_iterator it =
     _ns_id_to_name.find(id);
   if (it == _ns_id_to_name.end())
     return empty_string;
   else
     return it->second;
 }

◆ get_nodeset_name_map()

const std::map<boundary_id_type, std::string>& libMesh::BoundaryInfo::get_nodeset_name_map ( ) const

inline

Definition at line 868 of file boundary_info.h.

References _ns_id_to_name.

Referenced by libMesh::CheckpointIO::write_bc_names(), and libMesh::XdrIO::write_serialized_bc_names().

869 { return _ns_id_to_name; }

libMesh::BoundaryInfo::_ns_id_to_name

std::map< boundary_id_type, std::string > _ns_id_to_name

Definition: boundary_info.h:986

◆ get_shellface_boundary_ids()

const std::set<boundary_id_type>& libMesh::BoundaryInfo::get_shellface_boundary_ids ( ) const

inline

Returns: A reference to the set of all boundary IDs specified on shell faces.

Note: This is only relevant on shell elements.

Definition at line 806 of file boundary_info.h.

References _shellface_boundary_ids.

807 { return _shellface_boundary_ids; }

libMesh::BoundaryInfo::_shellface_boundary_ids

std::set< boundary_id_type > _shellface_boundary_ids

Definition: boundary_info.h:972

◆ get_side_and_node_maps()

void libMesh::BoundaryInfo::get_side_and_node_maps	(	UnstructuredMesh &	boundary_mesh,
		std::map< dof_id_type, dof_id_type > &	node_id_map,
		std::map< dof_id_type, unsigned char > &	side_id_map,
		Real	tolerance = `1.e-6`
	)

Suppose we have used sync to create boundary_mesh. Then each element in boundary_mesh will have interior_parent defined. This method gets extra data for us:

node_id_map stores a map from the node ids on the interior mesh to the corresponding node ids of boundary_mesh.
side_id_map stores a map from the element ids of the boundary mesh to the side index of the interior_parent that the boundary element corresponds to. tolerance is used to identify when we have matching elements.

Definition at line 282 of file boundary_info.C.

References libMesh::MeshBase::active_element_ptr_range(), libMesh::Elem::build_side_ptr(), libMesh::Elem::interior_parent(), libMesh::Real, side, and libMesh::Elem::side_index_range().

 {
   LOG_SCOPE("get_side_and_node_maps()", "BoundaryInfo");
 
   node_id_map.clear();
   side_id_map.clear();
 
   // Pull objects out of the loop to reduce heap operations
   std::unique_ptr<const Elem> interior_parent_side;
 
   for (const auto & boundary_elem : boundary_mesh.active_element_ptr_range())
     {
       const Elem * interior_parent = boundary_elem->interior_parent();
 
       // Find out which side of interior_parent boundary_elem corresponds to.
       // Use centroid comparison as a way to check.
       unsigned char interior_parent_side_index = 0;
       bool found_matching_sides = false;
       for (auto side : interior_parent->side_index_range())
         {
           interior_parent->build_side_ptr(interior_parent_side, side);
           Real centroid_distance = (boundary_elem->centroid() - interior_parent_side->centroid()).norm();
 
           if (centroid_distance < (tolerance * boundary_elem->hmin()))
             {
               interior_parent_side_index = cast_int<unsigned char>(side);
               found_matching_sides = true;
               break;
             }
         }
 
       if (!found_matching_sides)
         libmesh_error_msg("No matching side found within the specified tolerance");
 
       side_id_map[boundary_elem->id()] = interior_parent_side_index;
 
       for (auto local_node_index : boundary_elem->node_index_range())
         {
           dof_id_type boundary_node_id = boundary_elem->node_id(local_node_index);
           dof_id_type interior_node_id = interior_parent_side->node_id(local_node_index);
 
           node_id_map[interior_node_id] = boundary_node_id;
         }
     }
 }

◆ get_side_boundary_ids()

const std::set<boundary_id_type>& libMesh::BoundaryInfo::get_side_boundary_ids ( ) const

inline

Returns: A reference to the set of the boundary IDs specified on sides of semilocal mesh elements.

Definition at line 788 of file boundary_info.h.

References _side_boundary_ids.

Referenced by libMesh::MeshTools::Generation::build_extrusion(), and libMesh::Nemesis_IO_Helper::compute_num_global_sidesets().

789 { return _side_boundary_ids; }

libMesh::BoundaryInfo::_side_boundary_ids

std::set< boundary_id_type > _side_boundary_ids

Definition: boundary_info.h:944

◆ get_sideset_name()

const std::string & libMesh::BoundaryInfo::get_sideset_name ( boundary_id_type id ) const

Returns: A reference for getting an optional name for a sideset.

Definition at line 2360 of file boundary_info.C.

References _ss_id_to_name.

Referenced by libMesh::ExodusII_IO_Helper::write_sidesets().

 {
   static const std::string empty_string;
   std::map<boundary_id_type, std::string>::const_iterator it =
     _ss_id_to_name.find(id);
   if (it == _ss_id_to_name.end())
     return empty_string;
   else
     return it->second;
 }

◆ get_sideset_name_map()

const std::map<boundary_id_type, std::string>& libMesh::BoundaryInfo::get_sideset_name_map ( ) const

inline

Definition at line 860 of file boundary_info.h.

References _ss_id_to_name.

Referenced by libMesh::CheckpointIO::write_bc_names(), and libMesh::XdrIO::write_serialized_bc_names().

861 { return _ss_id_to_name; }

libMesh::BoundaryInfo::_ss_id_to_name

std::map< boundary_id_type, std::string > _ss_id_to_name

Definition: boundary_info.h:979

◆ has_boundary_id() [1/2]

bool libMesh::BoundaryInfo::has_boundary_id	(	const Node *const	node,
		const boundary_id_type	id
	)		const

Returns: true if node is associated with boundary id.

Definition at line 935 of file boundary_info.C.

References _boundary_node_id, and libMesh::as_range().

Referenced by libMesh::FEMContext::has_side_boundary_id().

 {
   for (const auto & pr : as_range(_boundary_node_id.equal_range(node)))
     if (pr.second == id)
       return true;
 
   return false;
 }

◆ has_boundary_id() [2/2]

bool libMesh::BoundaryInfo::has_boundary_id	(	const Elem *const	elem,
		const unsigned short int	side,
		const boundary_id_type	id
	)		const

Returns: true if side side of Elem elem is associated with id.

Definition at line 1184 of file boundary_info.C.

References boundary_ids(), and side.

 {
   std::vector<boundary_id_type> ids;
   this->boundary_ids(elem, side, ids);
   return (std::find(ids.begin(), ids.end(), id) != ids.end());
 }

◆ n_boundary_conds()

std::size_t libMesh::BoundaryInfo::n_boundary_conds ( ) const

Returns: The number of element-side-based boundary conditions.

This will be the correct global count even on a distributed mesh.

Definition at line 1646 of file boundary_info.C.

References _boundary_side_id, _mesh, libMesh::ParallelObject::comm(), libMesh::MeshBase::is_serial(), libMesh::ParallelObject::processor_id(), and libMesh::Parallel::Communicator::sum().

Referenced by libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Modification::flatten(), libMesh::AbaqusIO::read(), libMesh::Nemesis_IO::read(), libMesh::XdrIO::write(), and libMesh::GmshIO::write_mesh().

 {
   // in serial we know the number of bcs from the
   // size of the container
   if (_mesh.is_serial())
     return _boundary_side_id.size();
 
   // in parallel we need to sum the number of local bcs
   parallel_object_only();
 
   std::size_t nbcs=0;
 
   for (const auto & pr : _boundary_side_id)
     if (pr.first->processor_id() == this->processor_id())
       nbcs++;
 
   this->comm().sum (nbcs);
 
   return nbcs;
 }

◆ n_boundary_ids() [1/3]

std::size_t libMesh::BoundaryInfo::n_boundary_ids ( ) const

inline

Returns: The number of user-specified boundary ids on the semilocal part of the mesh.

Note: DistributedMesh users may need to compare boundary_ids sets via inter-processor communication.

Definition at line 354 of file boundary_info.h.

References _boundary_ids.

Referenced by libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::Parallel::Packing< T >::packable_size(), and libMesh::FroIO::write().

354 { return _boundary_ids.size(); }

libMesh::BoundaryInfo::_boundary_ids

std::set< boundary_id_type > _boundary_ids

Definition: boundary_info.h:935

◆ n_boundary_ids() [2/3]

unsigned int libMesh::BoundaryInfo::n_boundary_ids ( const Node * node ) const

Returns: The number of boundary ids associated with Node node.

Definition at line 972 of file boundary_info.C.

References _boundary_node_id.

 {
   auto pos = _boundary_node_id.equal_range(node);
   return cast_int<unsigned int>(std::distance(pos.first, pos.second));
 }

◆ n_boundary_ids() [3/3]

unsigned int libMesh::BoundaryInfo::n_boundary_ids	(	const Elem *const	elem,
		const unsigned short int	side
	)		const

Returns: The number of boundary ids associated with the side side of element elem.

Definition at line 1246 of file boundary_info.C.

References boundary_ids(), and side.

 {
   std::vector<boundary_id_type> ids;
   this->boundary_ids(elem, side, ids);
   return cast_int<unsigned int>(ids.size());
 }

◆ n_edge_boundary_ids()

unsigned int libMesh::BoundaryInfo::n_edge_boundary_ids	(	const Elem *const	elem,
		const unsigned short int	edge
	)		const

Returns: The number of boundary ids associated with the edge edge of element elem.

Note: Edge-based boundary IDs should only be used in 3D.

Definition at line 1051 of file boundary_info.C.

References edge_boundary_ids().

Referenced by libMesh::Parallel::Packing< T >::packable_size().

 {
   std::vector<boundary_id_type> ids;
   this->edge_boundary_ids(elem, edge, ids);
   return cast_int<unsigned int>(ids.size());
 }

◆ n_edge_conds()

std::size_t libMesh::BoundaryInfo::n_edge_conds ( ) const

Returns: The number of edge-based boundary conditions. Edge-based boundary IDs should only be used in 3D.

This will be the correct global count even on a distributed mesh.

Definition at line 1667 of file boundary_info.C.

References _boundary_edge_id, _mesh, libMesh::ParallelObject::comm(), libMesh::MeshBase::is_serial(), libMesh::ParallelObject::processor_id(), and libMesh::Parallel::Communicator::sum().

Referenced by libMesh::Nemesis_IO::prepare_to_write_nodal_data(), libMesh::Nemesis_IO::write(), libMesh::ExodusII_IO::write(), libMesh::XdrIO::write(), and libMesh::ExodusII_IO::write_nodal_data_common().

 {
   // in serial we know the number of nodesets from the
   // size of the container
   if (_mesh.is_serial())
     return _boundary_edge_id.size();
 
   // in parallel we need to sum the number of local nodesets
   parallel_object_only();
 
   std::size_t n_edge_bcs=0;
 
   for (const auto & pr : _boundary_edge_id)
     if (pr.first->processor_id() == this->processor_id())
       n_edge_bcs++;
 
   this->comm().sum (n_edge_bcs);
 
   return n_edge_bcs;
 }

◆ n_nodeset_conds()

std::size_t libMesh::BoundaryInfo::n_nodeset_conds ( ) const

Returns: The number of node-based boundary conditions.

This will be the correct global count even on a distributed mesh.

Definition at line 1711 of file boundary_info.C.

References _boundary_node_id, _mesh, libMesh::ParallelObject::comm(), libMesh::MeshBase::is_serial(), libMesh::ParallelObject::processor_id(), and libMesh::Parallel::Communicator::sum().

Referenced by libMesh::XdrIO::write().

 {
   // in serial we know the number of nodesets from the
   // size of the container
   if (_mesh.is_serial())
     return _boundary_node_id.size();
 
   // in parallel we need to sum the number of local nodesets
   parallel_object_only();
 
   std::size_t n_nodesets=0;
 
   for (const auto & pr : _boundary_node_id)
     if (pr.first->processor_id() == this->processor_id())
       n_nodesets++;
 
   this->comm().sum (n_nodesets);
 
   return n_nodesets;
 }

◆ n_processors()

processor_id_type libMesh::ParallelObject::n_processors ( ) const

inlineinherited

Returns: The number of processors in the group.

Definition at line 95 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::size().

96 { return cast_int<processor_id_type>(_communicator.size()); }

libMesh::Parallel::Communicator::size

processor_id_type size() const

Definition: communicator.h:175

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

◆ n_shellface_boundary_ids()

unsigned int libMesh::BoundaryInfo::n_shellface_boundary_ids	(	const Elem *const	elem,
		const unsigned short int	shellface
	)		const

Returns: The number of boundary ids associated with the specified shell face of element elem.

Note: This is only relevant for shell elements.

Definition at line 1130 of file boundary_info.C.

References shellface_boundary_ids().

Referenced by libMesh::Parallel::Packing< T >::packable_size().

 {
   std::vector<boundary_id_type> ids;
   this->shellface_boundary_ids(elem, shellface, ids);
   return cast_int<unsigned int>(ids.size());
 }

◆ n_shellface_conds()

std::size_t libMesh::BoundaryInfo::n_shellface_conds ( ) const

Returns: The number of shellface-based boundary conditions. This is only relevant on shell elements.

This will be the correct global count even on a distributed mesh.

Definition at line 1689 of file boundary_info.C.

References _boundary_shellface_id, _mesh, libMesh::ParallelObject::comm(), libMesh::MeshBase::is_serial(), libMesh::ParallelObject::processor_id(), and libMesh::Parallel::Communicator::sum().

Referenced by libMesh::XdrIO::write().

 {
   // in serial we know the number of nodesets from the
   // size of the container
   if (_mesh.is_serial())
     return _boundary_shellface_id.size();
 
   // in parallel we need to sum the number of local nodesets
   parallel_object_only();
 
   std::size_t n_shellface_bcs=0;
 
   for (const auto & pr : _boundary_shellface_id)
     if (pr.first->processor_id() == this->processor_id())
       n_shellface_bcs++;
 
   this->comm().sum (n_shellface_bcs);
 
   return n_shellface_bcs;
 }

◆ nodeset_name()

std::string & libMesh::BoundaryInfo::nodeset_name ( boundary_id_type id )

Returns: A writable reference for setting an optional name for a nodeset.

Definition at line 2388 of file boundary_info.C.

References _ns_id_to_name.

Referenced by libMesh::AbaqusIO::assign_boundary_node_ids(), libMesh::MeshTools::Generation::build_cube(), build_side_list_from_node_list(), and libMesh::ExodusII_IO::read().

 {
   return _ns_id_to_name[id];
 }

◆ operator=()

BoundaryInfo & libMesh::BoundaryInfo::operator= ( const BoundaryInfo & other_boundary_info )

Actual copying operation.

Note: The copy will have a reference to the same Mesh as the original.

We're going to attempt to pull new pointers out of the mesh assigned to this boundary info.

This will only work if the mesh assigned to this BoundaryInfo is the same mesh object as other_boundary_info or was constructed in exactly the same way (or constructed as a copy, or a refined copy without renumbering, etc.).

Definition at line 55 of file boundary_info.C.

References _boundary_edge_id, _boundary_ids, _boundary_node_id, _boundary_shellface_id, _boundary_side_id, _edge_boundary_ids, _mesh, _node_boundary_ids, _shellface_boundary_ids, _side_boundary_ids, clear(), libMesh::MeshBase::elem_ptr(), and libMesh::MeshBase::node_ptr().

 {
   // Overwrite any preexisting boundary info
   this->clear();
 
   // Copy node boundary info
   for (const auto & pr : other_boundary_info._boundary_node_id)
     _boundary_node_id.insert(std::make_pair(_mesh.node_ptr(pr.first->id()),
                                             pr.second));
 
   // Copy edge boundary info
   for (const auto & pr : other_boundary_info._boundary_edge_id)
     _boundary_edge_id.insert(std::make_pair(_mesh.elem_ptr(pr.first->id()),
                                             pr.second));
 
   // Copy shellface boundary info
   for (const auto & pr : other_boundary_info._boundary_shellface_id)
     _boundary_shellface_id.insert(std::make_pair(_mesh.elem_ptr(pr.first->id()),
                                                  pr.second));
 
   // Copy side boundary info
   for (const auto & pr : other_boundary_info._boundary_side_id)
     _boundary_side_id.insert(std::make_pair(_mesh.elem_ptr(pr.first->id()),
                                             pr.second));
 
   _boundary_ids = other_boundary_info._boundary_ids;
   _side_boundary_ids = other_boundary_info._side_boundary_ids;
   _node_boundary_ids = other_boundary_info._node_boundary_ids;
   _edge_boundary_ids = other_boundary_info._edge_boundary_ids;
   _shellface_boundary_ids = other_boundary_info._shellface_boundary_ids;
 
   return *this;
 }

◆ print_info()

void libMesh::BoundaryInfo::print_info ( std::ostream & out = libMesh::out ) const

Prints the boundary information data structure.

Definition at line 2217 of file boundary_info.C.

References _boundary_edge_id, _boundary_node_id, _boundary_shellface_id, and _boundary_side_id.

 {
   // Print out the nodal BCs
   if (!_boundary_node_id.empty())
     {
       out_stream << "Nodal Boundary conditions:" << std::endl
                  << "--------------------------" << std::endl
                  << "  (Node No., ID)               " << std::endl;
 
       for (const auto & pr : _boundary_node_id)
         out_stream << "  (" << pr.first->id()
                    << ", "  << pr.second
                    << ")"  << std::endl;
     }
 
   // Print out the element edge BCs
   if (!_boundary_edge_id.empty())
     {
       out_stream << std::endl
                  << "Edge Boundary conditions:" << std::endl
                  << "-------------------------" << std::endl
                  << "  (Elem No., Edge No., ID)      " << std::endl;
 
       for (const auto & pr : _boundary_edge_id)
         out_stream << "  (" << pr.first->id()
                    << ", "  << pr.second.first
                    << ", "  << pr.second.second
                    << ")"   << std::endl;
     }
 
   // Print out the element shellface BCs
   if (!_boundary_shellface_id.empty())
     {
       out_stream << std::endl
                  << "Shell-face Boundary conditions:" << std::endl
                  << "-------------------------" << std::endl
                  << "  (Elem No., Shell-face No., ID)      " << std::endl;
 
       for (const auto & pr : _boundary_shellface_id)
         out_stream << "  (" << pr.first->id()
                    << ", "  << pr.second.first
                    << ", "  << pr.second.second
                    << ")"   << std::endl;
     }
 
   // Print out the element side BCs
   if (!_boundary_side_id.empty())
     {
       out_stream << std::endl
                  << "Side Boundary conditions:" << std::endl
                  << "-------------------------" << std::endl
                  << "  (Elem No., Side No., ID)      " << std::endl;
 
       for (const auto & pr : _boundary_side_id)
         out_stream << "  (" << pr.first->id()
                    << ", "  << pr.second.first
                    << ", "  << pr.second.second
                    << ")"   << std::endl;
     }
 }

◆ print_summary()

void libMesh::BoundaryInfo::print_summary ( std::ostream & out = libMesh::out ) const

Prints a summary of the boundary information.

Definition at line 2280 of file boundary_info.C.

References _boundary_edge_id, _boundary_node_id, _boundary_shellface_id, and _boundary_side_id.

 {
   // Print out the nodal BCs
   if (!_boundary_node_id.empty())
     {
       out_stream << "Nodal Boundary conditions:" << std::endl
                  << "--------------------------" << std::endl
                  << "  (ID, number of nodes)   " << std::endl;
 
       std::map<boundary_id_type, std::size_t> ID_counts;
 
       for (const auto & pr : _boundary_node_id)
         ID_counts[pr.second]++;
 
       for (const auto & pr : ID_counts)
         out_stream << "  (" << pr.first
                    << ", "  << pr.second
                    << ")"  << std::endl;
     }
 
   // Print out the element edge BCs
   if (!_boundary_edge_id.empty())
     {
       out_stream << std::endl
                  << "Edge Boundary conditions:" << std::endl
                  << "-------------------------" << std::endl
                  << "  (ID, number of edges)   " << std::endl;
 
       std::map<boundary_id_type, std::size_t> ID_counts;
 
       for (const auto & pr : _boundary_edge_id)
         ID_counts[pr.second.second]++;
 
       for (const auto & pr : ID_counts)
         out_stream << "  (" << pr.first
                    << ", "  << pr.second
                    << ")"  << std::endl;
     }
 
 
   // Print out the element edge BCs
   if (!_boundary_shellface_id.empty())
     {
       out_stream << std::endl
                  << "Shell-face Boundary conditions:" << std::endl
                  << "-------------------------" << std::endl
                  << "  (ID, number of shellfaces)   " << std::endl;
 
       std::map<boundary_id_type, std::size_t> ID_counts;
 
       for (const auto & pr : _boundary_shellface_id)
         ID_counts[pr.second.second]++;
 
       for (const auto & pr : ID_counts)
         out_stream << "  (" << pr.first
                    << ", "  << pr.second
                    << ")"  << std::endl;
     }
 
   // Print out the element side BCs
   if (!_boundary_side_id.empty())
     {
       out_stream << std::endl
                  << "Side Boundary conditions:" << std::endl
                  << "-------------------------" << std::endl
                  << "  (ID, number of sides)   " << std::endl;
 
       std::map<boundary_id_type, std::size_t> ID_counts;
 
       for (const auto & pr : _boundary_side_id)
         ID_counts[pr.second.second]++;
 
       for (const auto & pr : ID_counts)
         out_stream << "  (" << pr.first
                    << ", "  << pr.second
                    << ")"  << std::endl;
     }
 }

◆ processor_id()

processor_id_type libMesh::ParallelObject::processor_id ( ) const

inlineinherited

Returns: The rank of this processor in the group.

Definition at line 101 of file parallel_object.h.

References libMesh::ParallelObject::_communicator, and libMesh::Parallel::Communicator::rank().

102 { return cast_int<processor_id_type>(_communicator.rank()); }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:107

libMesh::Parallel::Communicator::rank

processor_id_type rank() const

Definition: communicator.h:173

◆ raw_boundary_ids() [1/2]

std::vector< boundary_id_type > libMesh::BoundaryInfo::raw_boundary_ids	(	const Elem *const	elem,
		const unsigned short int	side
	)		const

Returns: The list of raw boundary ids associated with the side side of element elem.

These ids are "raw" because they exclude ids which are implicit, such as a child's inheritance of its ancestors' boundary id.

Deprecated:: Instead, use the version of this function that fills a std::vector.

Definition at line 1257 of file boundary_info.C.

References side.

Referenced by copy_boundary_ids().

 {
   libmesh_deprecated();
 
   std::vector<boundary_id_type> ids;
   this->raw_boundary_ids(elem, side, ids);
   return ids;
 }

◆ raw_boundary_ids() [2/2]

void libMesh::BoundaryInfo::raw_boundary_ids	(	const Elem *const	elem,
		const unsigned short int	side,
		std::vector< boundary_id_type > &	vec_to_fill
	)		const

Returns: The list of raw boundary ids associated with the side side of element elem.

These ids are "raw" because they exclude ids which are implicit, such as a child's inheritance of its ancestors' boundary id.

This is the non-deprecated version of the function.

Definition at line 1270 of file boundary_info.C.

References _boundary_side_id, libMesh::as_range(), libMesh::Elem::parent(), and side.

 {
   libmesh_assert(elem);
 
   // Clear out any previous contents
   vec_to_fill.clear();
 
   // Only level-0 elements store BCs.
   if (elem->parent())
     return;
 
   // Check each element in the range to see if its side matches the requested side.
   for (const auto & pr : as_range(_boundary_side_id.equal_range(elem)))
     if (pr.second.first == side)
       vec_to_fill.push_back(pr.second.second);
 }

◆ raw_edge_boundary_ids() [1/2]

std::vector< boundary_id_type > libMesh::BoundaryInfo::raw_edge_boundary_ids	(	const Elem *const	elem,
		const unsigned short int	edge
	)		const

Returns: The list of raw boundary ids associated with the edge edge of element elem.

These ids are "raw" because they exclude ids which are implicit, such as a child's inheritance of its ancestors' boundary id.

Note: Edge-based boundary IDs should only be used in 3D.

Deprecated:: Instead, use the version of this function that fills a std::vector.

Definition at line 1062 of file boundary_info.C.

Referenced by copy_boundary_ids().

 {
   libmesh_deprecated();
 
   std::vector<boundary_id_type> ids;
   this->raw_edge_boundary_ids(elem, edge, ids);
   return ids;
 }

◆ raw_edge_boundary_ids() [2/2]

void libMesh::BoundaryInfo::raw_edge_boundary_ids	(	const Elem *const	elem,
		const unsigned short int	edge,
		std::vector< boundary_id_type > &	vec_to_fill
	)		const

Returns: The list of raw boundary ids associated with the edge edge of element elem.

These ids are "raw" because they exclude ids which are implicit, such as a child's inheritance of its ancestors' boundary id.

Note: Edge-based boundary IDs should only be used in 3D.

This is the non-deprecated version of the function.

Definition at line 1075 of file boundary_info.C.

References _boundary_edge_id, libMesh::as_range(), and libMesh::Elem::parent().

 {
   libmesh_assert(elem);
 
   // Clear out any previous contents
   vec_to_fill.clear();
 
   // Only level-0 elements store BCs.
   if (elem->parent())
     return;
 
   // Check each element in the range to see if its edge matches the requested edge.
   for (const auto & pr : as_range(_boundary_edge_id.equal_range(elem)))
     if (pr.second.first == edge)
       vec_to_fill.push_back(pr.second.second);
 }

◆ raw_shellface_boundary_ids()

void libMesh::BoundaryInfo::raw_shellface_boundary_ids	(	const Elem *const	elem,
		const unsigned short int	shellface,
		std::vector< boundary_id_type > &	vec_to_fill
	)		const

Returns: The list of raw boundary ids associated with the specified shell face of element elem.

These ids are "raw" because they exclude ids which are implicit, such as a child's inheritance of its ancestors' boundary id.

Note: This is only relevant for shell elements.

Definition at line 1140 of file boundary_info.C.

References _boundary_shellface_id, libMesh::as_range(), and libMesh::Elem::parent().

Referenced by copy_boundary_ids().

 {
   libmesh_assert(elem);
 
   // Shells only have 2 faces
   libmesh_assert_less(shellface, 2);
 
   // Clear out any previous contents
   vec_to_fill.clear();
 
   // Only level-0 elements store BCs.
   if (elem->parent())
     return;
 
   // Check each element in the range to see if its shellface matches the requested shellface.
   for (const auto & pr : as_range(_boundary_shellface_id.equal_range(elem)))
     if (pr.second.first == shellface)
       vec_to_fill.push_back(pr.second.second);
 }

◆ regenerate_id_sets()

void libMesh::BoundaryInfo::regenerate_id_sets ( )

Clears and regenerates the cached sets of ids. This is necessary after use of remove_*() functions, which remove individual id associations (an O(1) process) without checking to see whether that is the last association with the id (an O(N) process.

Definition at line 122 of file boundary_info.C.

References _boundary_edge_id, _boundary_ids, _boundary_node_id, _boundary_shellface_id, _boundary_side_id, _edge_boundary_ids, _node_boundary_ids, _shellface_boundary_ids, and _side_boundary_ids.

Referenced by libMesh::UnstructuredMesh::all_first_order(), libMesh::TetGenMeshInterface::delete_2D_hull_elements(), libMesh::MeshCommunication::delete_remote_elements(), libMesh::TetGenMeshInterface::pointset_convexhull(), and libMesh::ReplicatedMesh::stitching_helper().

 {
   // Clear the old caches
   _boundary_ids.clear();
   _side_boundary_ids.clear();
   _node_boundary_ids.clear();
   _edge_boundary_ids.clear();
   _shellface_boundary_ids.clear();
 
   // Loop over id maps to regenerate each set.
   for (const auto & pr : _boundary_node_id)
     {
       const boundary_id_type id = pr.second;
       _boundary_ids.insert(id);
       _node_boundary_ids.insert(id);
     }
 
   for (const auto & pr : _boundary_edge_id)
     {
       const boundary_id_type id = pr.second.second;
       _boundary_ids.insert(id);
       _edge_boundary_ids.insert(id);
     }
 
   for (const auto & pr : _boundary_side_id)
     {
       const boundary_id_type id = pr.second.second;
       _boundary_ids.insert(id);
       _side_boundary_ids.insert(id);
     }
 
   for (const auto & pr : _boundary_shellface_id)
     {
       const boundary_id_type id = pr.second.second;
       _boundary_ids.insert(id);
       _shellface_boundary_ids.insert(id);
     }
 }

◆ remove() [1/2]

void libMesh::BoundaryInfo::remove ( const Node * node )

Removes the boundary conditions associated with node node, if any exist.

Definition at line 1321 of file boundary_info.C.

References _boundary_node_id.

Referenced by libMesh::MeshRefinement::_coarsen_elements(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Modification::change_boundary_id(), libMesh::ReplicatedMesh::delete_elem(), libMesh::DistributedMesh::delete_elem(), libMesh::ReplicatedMesh::delete_node(), libMesh::DistributedMesh::delete_node(), libMesh::ReplicatedMesh::renumber_nodes_and_elements(), and libMesh::DistributedMesh::renumber_nodes_and_elements().

 {
   libmesh_assert(node);
 
   // Erase everything associated with node
   _boundary_node_id.erase (node);
 }

◆ remove() [2/2]

void libMesh::BoundaryInfo::remove ( const Elem * elem )

Removes the boundary conditions associated with element elem, if any exist.

Definition at line 1331 of file boundary_info.C.

References _boundary_edge_id, _boundary_shellface_id, and _boundary_side_id.

 {
   libmesh_assert(elem);
 
   // Erase everything associated with elem
   _boundary_edge_id.erase (elem);
   _boundary_side_id.erase (elem);
   _boundary_shellface_id.erase (elem);
 }

◆ remove_edge() [1/2]

void libMesh::BoundaryInfo::remove_edge	(	const Elem *	elem,
		const unsigned short int	edge
	)

Removes all boundary conditions associated with edge edge of element elem, if any exist.

Definition at line 1343 of file boundary_info.C.

References _boundary_edge_id, and libMesh::Elem::level().

Referenced by libMesh::MeshTools::Modification::change_boundary_id().

 {
   libmesh_assert(elem);
 
   // The user shouldn't be trying to remove only one child's boundary
   // id
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Some older compilers don't support erasing from a map with
   // const_iterators, so we explicitly use non-const iterators here.
   auto e = _boundary_edge_id.equal_range(elem);
 
   // elem may be there, maybe multiple occurrences
   while (e.first != e.second)
     {
       // if this is true we found the requested edge
       // of the element and want to erase the id
       if (e.first->second.first == edge)
         e.first = _boundary_edge_id.erase(e.first);
       else
         ++e.first;
     }
 }

◆ remove_edge() [2/2]

void libMesh::BoundaryInfo::remove_edge	(	const Elem *	elem,
		const unsigned short int	edge,
		const boundary_id_type	id
	)

Removes the boundary id id from edge edge of element elem, if it exists.

Definition at line 1370 of file boundary_info.C.

References _boundary_edge_id, and libMesh::Elem::level().

 {
   libmesh_assert(elem);
 
   // The user shouldn't be trying to remove only one child's boundary
   // id
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Some older compilers don't support erasing from a map with
   // const_iterators, so we explicitly use non-const iterators here.
   auto e = _boundary_edge_id.equal_range(elem);
 
   // elem may be there, maybe multiple occurrences
   while (e.first != e.second)
     {
       // if this is true we found the requested edge
       // of the element and want to erase the requested id
       if (e.first->second.first == edge && e.first->second.second == id)
         e.first = _boundary_edge_id.erase(e.first);
       else
         ++e.first;
     }
 }

◆ remove_id()

void libMesh::BoundaryInfo::remove_id ( boundary_id_type id )

Removes all entities (nodes, sides, edges, shellfaces) with boundary id id from their respective containers and erases any record of id's existence from the BoundaryInfo object. That is, after calling remove_id(), id will no longer be in the sets returned by get_boundary_ids(), get_side_boundary_ids(), etc., and will not be in the bc_id_list vector returned by build_side_list(), etc.

Definition at line 1511 of file boundary_info.C.

References _boundary_edge_id, _boundary_ids, _boundary_node_id, _boundary_shellface_id, _boundary_side_id, _edge_boundary_ids, _node_boundary_ids, _ns_id_to_name, _shellface_boundary_ids, _side_boundary_ids, and _ss_id_to_name.

Referenced by libMesh::MeshTools::Modification::change_boundary_id().

 {
   // Erase id from ids containers
   _boundary_ids.erase(id);
   _side_boundary_ids.erase(id);
   _edge_boundary_ids.erase(id);
   _shellface_boundary_ids.erase(id);
   _node_boundary_ids.erase(id);
   _ss_id_to_name.erase(id);
   _ns_id_to_name.erase(id);
 
   // Erase pointers to geometric entities with this id.
   for (auto it = _boundary_node_id.begin(); it != _boundary_node_id.end(); /*below*/)
     {
       if (it->second == id)
         it = _boundary_node_id.erase(it);
       else
         ++it;
     }
 
   for (auto it = _boundary_edge_id.begin(); it != _boundary_edge_id.end(); /*below*/)
     {
       if (it->second.second == id)
         it = _boundary_edge_id.erase(it);
       else
         ++it;
     }
 
   for (auto it = _boundary_shellface_id.begin(); it != _boundary_shellface_id.end(); /*below*/)
     {
       if (it->second.second == id)
         it = _boundary_shellface_id.erase(it);
       else
         ++it;
     }
 
   for (auto it = _boundary_side_id.begin(); it != _boundary_side_id.end(); /*below*/)
     {
       if (it->second.second == id)
         it = _boundary_side_id.erase(it);
       else
         ++it;
     }
 }

◆ remove_shellface() [1/2]

void libMesh::BoundaryInfo::remove_shellface	(	const Elem *	elem,
		const unsigned short int	shellface
	)

Removes all boundary conditions associated with shell face shellface of element elem, if any exist.

Definition at line 1397 of file boundary_info.C.

References _boundary_shellface_id, and libMesh::Elem::level().

Referenced by libMesh::MeshTools::Modification::change_boundary_id().

 {
   libmesh_assert(elem);
 
   // The user shouldn't be trying to remove only one child's boundary
   // id
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Shells only have 2 faces
   libmesh_assert_less(shellface, 2);
 
   // Some older compilers don't support erasing from a map with
   // const_iterators, so we explicitly use non-const iterators here.
   auto e = _boundary_shellface_id.equal_range(elem);
 
   // elem may be there, maybe multiple occurrences
   while (e.first != e.second)
     {
       // if this is true we found the requested shellface
       // of the element and want to erase the id
       if (e.first->second.first == shellface)
         e.first = _boundary_shellface_id.erase(e.first);
       else
         ++e.first;
     }
 }

◆ remove_shellface() [2/2]

void libMesh::BoundaryInfo::remove_shellface	(	const Elem *	elem,
		const unsigned short int	shellface,
		const boundary_id_type	id
	)

Removes all boundary conditions associated with shell face shellface of element elem, if any exist.

Definition at line 1427 of file boundary_info.C.

References _boundary_shellface_id, and libMesh::Elem::level().

 {
   libmesh_assert(elem);
 
   // The user shouldn't be trying to remove only one child's boundary
   // id
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Shells only have 2 faces
   libmesh_assert_less(shellface, 2);
 
   // Some older compilers don't support erasing from a map with
   // const_iterators, so we explicitly use non-const iterators here.
   auto e = _boundary_shellface_id.equal_range(elem);
 
   // elem may be there, maybe multiple occurrences
   while (e.first != e.second)
     {
       // if this is true we found the requested shellface
       // of the element and want to erase the requested id
       if (e.first->second.first == shellface &&
           e.first->second.second == id)
         {
           // (postfix++ - increment the iterator before it's invalid)
           e.first = _boundary_shellface_id.erase(e.first);
         }
       else
         ++e.first;
     }
 }

◆ remove_side() [1/2]

void libMesh::BoundaryInfo::remove_side	(	const Elem *	elem,
		const unsigned short int	side
	)

Removes all boundary conditions associated with side side of element elem, if any exist.

Definition at line 1460 of file boundary_info.C.

References _boundary_side_id, libMesh::Elem::level(), and side.

Referenced by libMesh::MeshTools::Modification::change_boundary_id(), and libMesh::ReplicatedMesh::stitching_helper().

 {
   libmesh_assert(elem);
 
   // The user shouldn't be trying to remove only one child's boundary
   // id
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Some older compilers don't support erasing from a map with
   // const_iterators, so we explicitly use non-const iterators here.
   auto e = _boundary_side_id.equal_range(elem);
 
   // elem may be there, maybe multiple occurrences
   while (e.first != e.second)
     {
       // if this is true we found the requested side
       // of the element and want to erase the id
       if (e.first->second.first == side)
         e.first = _boundary_side_id.erase(e.first);
       else
         ++e.first;
     }
 }

◆ remove_side() [2/2]

void libMesh::BoundaryInfo::remove_side	(	const Elem *	elem,
		const unsigned short int	side,
		const boundary_id_type	id
	)

Removes the boundary id id from side side of element elem, if it exists.

Definition at line 1487 of file boundary_info.C.

References _boundary_side_id, and side.

 {
   libmesh_assert(elem);
 
   // Some older compilers don't support erasing from a map with
   // const_iterators, so we explicitly use non-const iterators here.
   auto e = _boundary_side_id.equal_range(elem);
 
   // elem may be there, maybe multiple occurrences
   while (e.first != e.second)
     {
       // if this is true we found the requested side
       // of the element and want to erase the requested id
       if (e.first->second.first == side && e.first->second.second == id)
         e.first = _boundary_side_id.erase(e.first);
       else
         ++e.first;
     }
 }

◆ set_nodeset_name_map()

std::map<boundary_id_type, std::string>& libMesh::BoundaryInfo::set_nodeset_name_map ( )

inline

Returns: A writable reference to the nodeset name map.

Definition at line 866 of file boundary_info.h.

References _ns_id_to_name.

Referenced by libMesh::CheckpointIO::read_bc_names(), libMesh::CheckpointIO::read_header(), and libMesh::XdrIO::read_serialized_bc_names().

867 { return _ns_id_to_name; }

libMesh::BoundaryInfo::_ns_id_to_name

std::map< boundary_id_type, std::string > _ns_id_to_name

Definition: boundary_info.h:986

◆ set_sideset_name_map()

std::map<boundary_id_type, std::string>& libMesh::BoundaryInfo::set_sideset_name_map ( )

inline

Returns: A writable reference to the sideset name map.

Definition at line 858 of file boundary_info.h.

References _ss_id_to_name.

Referenced by libMesh::CheckpointIO::read_bc_names(), libMesh::CheckpointIO::read_header(), and libMesh::XdrIO::read_serialized_bc_names().

859 { return _ss_id_to_name; }

libMesh::BoundaryInfo::_ss_id_to_name

std::map< boundary_id_type, std::string > _ss_id_to_name

Definition: boundary_info.h:979

◆ shellface_boundary_ids()

void libMesh::BoundaryInfo::shellface_boundary_ids	(	const Elem *const	elem,
		const unsigned short int	shellface,
		std::vector< boundary_id_type > &	vec_to_fill
	)		const

Returns: The list of boundary ids associated with the specified shell face of element elem.

Note: This is only relevant for shell elements.

Definition at line 1096 of file boundary_info.C.

References _boundary_shellface_id, libMesh::as_range(), libMesh::Elem::level(), and libMesh::Elem::parent().

Referenced by libMesh::MeshTools::Modification::change_boundary_id(), n_shellface_boundary_ids(), libMesh::Parallel::Packing< T >::pack(), and libMesh::XdrIO::write_serialized_bcs_helper().

 {
   libmesh_assert(elem);
 
   // Shells only have 2 faces
   libmesh_assert_less(shellface, 2);
 
   // Clear out any previous contents
   vec_to_fill.clear();
 
   // Only level-0 elements store BCs.  If this is not a level-0
   // element get its level-0 parent and infer the BCs.
   const Elem * searched_elem = elem;
 #ifdef LIBMESH_ENABLE_AMR
   if (elem->level() != 0)
     {
       while (searched_elem->parent() != nullptr)
         {
           const Elem * parent = searched_elem->parent();
           searched_elem = parent;
         }
     }
 #endif
 
   // Check each element in the range to see if its shellface matches the requested shellface.
   for (const auto & pr : as_range(_boundary_shellface_id.equal_range(searched_elem)))
     if (pr.second.first == shellface)
       vec_to_fill.push_back(pr.second.second);
 }

◆ side_with_boundary_id()

unsigned int libMesh::BoundaryInfo::side_with_boundary_id	(	const Elem *const	elem,
		const boundary_id_type	boundary_id
	)		const

Returns: A side of element elem whose associated boundary id is boundary_id if such a side exists, and invalid_uint otherwise.

Note: If multiple sides of elem have the same id, only the lowest numbered such side is returned.

Definition at line 1558 of file boundary_info.C.

References _boundary_side_id, libMesh::as_range(), libMesh::invalid_uint, libMesh::Elem::is_child_on_side(), libMesh::Elem::level(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::parent(), side, libMesh::Elem::top_parent(), and libMesh::Elem::which_child_am_i().

Referenced by libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints().

 {
   const Elem * searched_elem = elem;
   if (elem->level() != 0)
     searched_elem = elem->top_parent();
 
   // elem may have zero or multiple occurrences
   for (const auto & pr : as_range(_boundary_side_id.equal_range(searched_elem)))
     {
       // if this is true we found the requested boundary_id
       // of the element and want to return the side
       if (pr.second.second == boundary_id_in)
         {
           unsigned int side = pr.second.first;
 
           // If we're on this external boundary then we share this
           // external boundary id
           if (elem->neighbor_ptr(side) == nullptr)
             return side;
 
           // If we're on an internal boundary then we need to be sure
           // it's the same internal boundary as our top_parent
           const Elem * p = elem;
 
 #ifdef LIBMESH_ENABLE_AMR
 
           while (p != nullptr)
             {
               const Elem * parent = p->parent();
               if (!parent->is_child_on_side(parent->which_child_am_i(p), side))
                 break;
               p = parent;
             }
 #endif
           // We're on that side of our top_parent; return it
           if (!p)
             return side;
         }
     }
 
   // if we get here, we found elem in the data structure but not
   // the requested boundary id, so return the default value
   return libMesh::invalid_uint;
 }

◆ sideset_name()

std::string & libMesh::BoundaryInfo::sideset_name ( boundary_id_type id )

Returns: A writable reference for setting an optional name for a sideset.

Definition at line 2372 of file boundary_info.C.

References _ss_id_to_name.

Referenced by libMesh::AbaqusIO::assign_sideset_ids(), libMesh::MeshTools::Generation::build_cube(), build_side_list_from_node_list(), libMesh::UNVIO::groups_in(), libMesh::ExodusII_IO::read(), and libMesh::GmshIO::read_mesh().

 {
   return _ss_id_to_name[id];
 }

◆ sync() [1/3]

void libMesh::BoundaryInfo::sync ( UnstructuredMesh & boundary_mesh )

Generates boundary_mesh data structures corresponding to the mesh data structures. Allows the boundary_mesh to be used like any other mesh, except with interior_parent() values defined for algorithms which couple boundary and interior mesh information. Any pre-existing boundary_mesh data is cleared.

Definition at line 163 of file boundary_info.C.

References _boundary_ids, _mesh, libMesh::ParallelObject::comm(), invalid_id, libMesh::MeshBase::is_serial(), and libMesh::Parallel::Communicator::set_union().

Referenced by sync().

 {
   std::set<boundary_id_type> request_boundary_ids(_boundary_ids);
   request_boundary_ids.insert(invalid_id);
   if (!_mesh.is_serial())
     this->comm().set_union(request_boundary_ids);
 
   this->sync(request_boundary_ids,
              boundary_mesh);
 }

◆ sync() [2/3]

void libMesh::BoundaryInfo::sync	(	const std::set< boundary_id_type > &	requested_boundary_ids,
		UnstructuredMesh &	boundary_mesh
	)

Generates boundary_mesh data structures corresponding to the mesh data structures. Allows the boundary_mesh to be used like any other mesh, except with interior_parent() values defined for algorithms which couple boundary and interior mesh information. Any pre-existing boundary_mesh data is cleared. Only boundary elements with the specified ids are extracted. Boundary IDs for the nodes on requested_boundary_ids will also be copied over to boundary_mesh. We do not currently copy edge boundary IDs over to boundary_mesh.

Definition at line 176 of file boundary_info.C.

References libMesh::Elem::invalid_subdomain_id, and sync().

 {
   // Call the 3 argument version of this function with a dummy value for the third set.
   std::set<subdomain_id_type> subdomains_relative_to;
   subdomains_relative_to.insert(Elem::invalid_subdomain_id);
 
   this->sync(requested_boundary_ids,
              boundary_mesh,
              subdomains_relative_to);
 }

◆ sync() [3/3]

void libMesh::BoundaryInfo::sync	(	const std::set< boundary_id_type > &	requested_boundary_ids,
		UnstructuredMesh &	boundary_mesh,
		const std::set< subdomain_id_type > &	subdomains_relative_to
	)

Like the other sync() implementations, but specifically intended for building "boundary" meshes from internal sidesets. In the case of an internal sideset, each side may belong to 2 higher-dimensional parent elements, and typically we do not want to add the same side to the boundary mesh twice. The std::set<subdomain_id_type> passed into this function specifies which subdomain the sides in question should relative to, so that they are only added once.

Deleting 0 elements seems weird, but it's better encapsulating than exposing a set_is_serial(false) capability that might be easily misused.

If the boundary_mesh is still serial, that means we can't parallelize it, so to make sure we can construct it in full on every processor we'll serialize the interior mesh. Use a temporary serializer here.

Re-create the boundary mesh.

Definition at line 190 of file boundary_info.C.

 {
   LOG_SCOPE("sync()", "BoundaryInfo");
 
   boundary_mesh.clear();
 
   if (!_mesh.is_serial())
     boundary_mesh.delete_remote_elements();
 
   MeshSerializer serializer
     (const_cast<MeshBase &>(_mesh), boundary_mesh.is_serial());
 
   boundary_mesh.set_n_partitions() = _mesh.n_partitions();
 
   std::map<dof_id_type, dof_id_type> node_id_map;
   std::map<std::pair<dof_id_type, unsigned char>, dof_id_type> side_id_map;
 
   this->_find_id_maps(requested_boundary_ids, 0, &node_id_map, 0, &side_id_map, subdomains_relative_to);
 
   // Let's add all the boundary nodes we found to the boundary mesh
   for (const auto & node : _mesh.node_ptr_range())
     {
       dof_id_type node_id = node->id();
       if (node_id_map.count(node_id))
         {
           boundary_mesh.add_point(*node, node_id_map[node_id], node->processor_id());
 
           // Copy over all the node's boundary IDs to boundary_mesh
           std::vector<boundary_id_type> node_boundary_ids;
           this->boundary_ids(node, node_boundary_ids);
           for (const auto & node_bid : node_boundary_ids)
             boundary_mesh.get_boundary_info().add_node(node_id_map[node_id], node_bid);
         }
     }
 
   // Let's add the elements
   this->add_elements (requested_boundary_ids, boundary_mesh, subdomains_relative_to);
 
   // The new elements are currently using the interior mesh's nodes;
   // we want them to use the boundary mesh's nodes instead.
 
   // This side's Node pointers still point to the nodes of the original mesh.
   // We need to re-point them to the boundary mesh's nodes!  Since we copied *ALL* of
   // the original mesh's nodes over, we should be guaranteed to have the same ordering.
   for (auto & new_elem : boundary_mesh.element_ptr_range())
     {
       for (auto nn : new_elem->node_index_range())
         {
           // Get the correct node pointer, based on the id()
           Node * new_node =
             boundary_mesh.node_ptr(node_id_map[new_elem->node_id(nn)]);
 
           // sanity check: be sure that the new Node exists and its
           // global id really matches
           libmesh_assert (new_node);
           libmesh_assert_equal_to (new_node->id(),
                                    node_id_map[new_elem->node_id(nn)]);
 
           // Assign the new node pointer
           new_elem->set_node(nn) = new_node;
         }
     }
 
   // Don't repartition this mesh; we want it to stay in sync with the
   // interior partitioning.
   boundary_mesh.partitioner().reset(nullptr);
 
   // Make boundary_mesh nodes and elements contiguous
   boundary_mesh.prepare_for_use(/*skip_renumber =*/ false);
 
   // and finally distribute element partitioning to the nodes
   Partitioner::set_node_processor_ids(boundary_mesh);
 }

Friends And Related Function Documentation

◆ MeshBase

friend class MeshBase

friend

Definition at line 60 of file boundary_info.h.

Member Data Documentation

◆ _boundary_edge_id

std::multimap<const Elem *, std::pair<unsigned short int, boundary_id_type> > libMesh::BoundaryInfo::_boundary_edge_id

private

Data structure that maps edges of elements to boundary ids. This is only relevant in 3D.

Definition at line 910 of file boundary_info.h.

Referenced by add_edge(), build_edge_list(), clear(), edge_boundary_ids(), n_edge_conds(), operator=(), print_info(), print_summary(), raw_edge_boundary_ids(), regenerate_id_sets(), remove(), remove_edge(), and remove_id().

◆ _boundary_ids

std::set<boundary_id_type> libMesh::BoundaryInfo::_boundary_ids

private

A collection of user-specified boundary ids for sides, edges, nodes, and shell faces. See _side_boundary_ids, _edge_boundary_ids, _node_boundary_ids, and _shellface_boundary_ids for sets containing IDs for only sides, edges, nodes, and shell faces, respectively.

Definition at line 935 of file boundary_info.h.

Referenced by add_edge(), add_node(), add_shellface(), add_side(), clear(), get_boundary_ids(), n_boundary_ids(), operator=(), regenerate_id_sets(), remove_id(), and sync().

◆ _boundary_node_id

std::multimap<const Node *, boundary_id_type> libMesh::BoundaryInfo::_boundary_node_id

private

Data structure that maps nodes in the mesh to boundary ids.

Definition at line 902 of file boundary_info.h.

Referenced by add_node(), boundary_ids(), build_node_boundary_ids(), build_node_list(), build_side_list_from_node_list(), clear(), clear_boundary_node_ids(), has_boundary_id(), n_boundary_ids(), n_nodeset_conds(), operator=(), print_info(), print_summary(), regenerate_id_sets(), remove(), and remove_id().

◆ _boundary_shellface_id

std::multimap<const Elem *, std::pair<unsigned short int, boundary_id_type> > libMesh::BoundaryInfo::_boundary_shellface_id

private

Data structure that maps faces of shell elements to boundary ids. This is only relevant for shell elements.

Definition at line 918 of file boundary_info.h.

Referenced by add_shellface(), build_shellface_boundary_ids(), build_shellface_list(), clear(), n_shellface_conds(), operator=(), print_info(), print_summary(), raw_shellface_boundary_ids(), regenerate_id_sets(), remove(), remove_id(), remove_shellface(), and shellface_boundary_ids().

◆ _boundary_side_id

std::multimap<const Elem *, std::pair<unsigned short int, boundary_id_type> > libMesh::BoundaryInfo::_boundary_side_id

private

Data structure that maps sides of elements to boundary ids.

Definition at line 926 of file boundary_info.h.

Referenced by _find_id_maps(), add_elements(), add_side(), boundary_ids(), build_active_side_list(), build_node_list_from_side_list(), build_side_boundary_ids(), build_side_list(), clear(), n_boundary_conds(), operator=(), print_info(), print_summary(), raw_boundary_ids(), regenerate_id_sets(), remove(), remove_id(), remove_side(), and side_with_boundary_id().

◆ _communicator

const Parallel::Communicator& libMesh::ParallelObject::_communicator

protectedinherited

Definition at line 107 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::ParallelObject::comm(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), and libMesh::ParallelObject::processor_id().

◆ _edge_boundary_ids

std::set<boundary_id_type> libMesh::BoundaryInfo::_edge_boundary_ids

private

Set of user-specified boundary IDs for edges only. This is only relevant in 3D.

Note: _boundary_ids is the union of this set, _side_boundary_ids, _node_boundary_ids, and _shellface_boundary_ids.

Definition at line 953 of file boundary_info.h.

Referenced by add_edge(), clear(), get_edge_boundary_ids(), operator=(), regenerate_id_sets(), and remove_id().

◆ _mesh

MeshBase& libMesh::BoundaryInfo::_mesh

private

The Mesh this boundary info pertains to.

Definition at line 895 of file boundary_info.h.

Referenced by _find_id_maps(), add_edge(), add_elements(), add_node(), add_shellface(), add_side(), build_node_list_from_side_list(), build_side_list_from_node_list(), n_boundary_conds(), n_edge_conds(), n_nodeset_conds(), n_shellface_conds(), operator=(), and sync().

◆ _node_boundary_ids

std::set<boundary_id_type> libMesh::BoundaryInfo::_node_boundary_ids

private

Set of user-specified boundary IDs for nodes only.

Note: _boundary_ids is the union of this set, _edge_boundary_ids, _side_boundary_ids, and _shellface_boundary_ids.

Definition at line 962 of file boundary_info.h.

Referenced by add_node(), clear(), get_node_boundary_ids(), operator=(), regenerate_id_sets(), and remove_id().

◆ _ns_id_to_name

std::map<boundary_id_type, std::string> libMesh::BoundaryInfo::_ns_id_to_name

private

This structure maintains the mapping of named node sets for file formats that support named blocks. Currently this is only implemented for ExodusII

Definition at line 986 of file boundary_info.h.

Referenced by get_id_by_name(), get_nodeset_name(), get_nodeset_name_map(), nodeset_name(), remove_id(), and set_nodeset_name_map().

◆ _shellface_boundary_ids

std::set<boundary_id_type> libMesh::BoundaryInfo::_shellface_boundary_ids

private

Set of user-specified boundary IDs for shellfaces only. This is only relevant for shell elements.

Note: _boundary_ids is the union of this set, _side_boundary_ids, _edge_boundary_ids, and _node_boundary_ids.

Definition at line 972 of file boundary_info.h.

Referenced by add_shellface(), clear(), get_shellface_boundary_ids(), operator=(), regenerate_id_sets(), and remove_id().

◆ _side_boundary_ids

std::set<boundary_id_type> libMesh::BoundaryInfo::_side_boundary_ids

private

Set of user-specified boundary IDs for sides only.

Note: _boundary_ids is the union of this set, _edge_boundary_ids, _node_boundary_ids, and _shellface_boundary_ids.

Definition at line 944 of file boundary_info.h.

Referenced by add_side(), clear(), get_side_boundary_ids(), operator=(), regenerate_id_sets(), and remove_id().

◆ _ss_id_to_name

std::map<boundary_id_type, std::string> libMesh::BoundaryInfo::_ss_id_to_name

private

This structure maintains the mapping of named side sets for file formats that support named blocks. Currently this is only implemented for ExodusII

Definition at line 979 of file boundary_info.h.

Referenced by get_id_by_name(), get_sideset_name(), get_sideset_name_map(), remove_id(), set_sideset_name_map(), and sideset_name().

◆ invalid_id

const boundary_id_type libMesh::BoundaryInfo::invalid_id = -123

static

Number used for internal use. This is the return value if a boundary condition is not specified.

Definition at line 875 of file boundary_info.h.

Referenced by _find_id_maps(), add_edge(), add_elements(), add_node(), add_shellface(), add_side(), libMesh::MeshTools::Modification::all_tri(), boundary_id(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Modification::flatten(), get_id_by_name(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), libMesh::ReplicatedMesh::stitching_helper(), sync(), libMesh::XdrIO::write_serialized_bcs_helper(), and libMesh::XdrIO::write_serialized_nodesets().

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

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ BoundaryInfo()

◆ ~BoundaryInfo()

Member Function Documentation

◆ _find_id_maps()

◆ add_edge() [1/3]

◆ add_edge() [2/3]

◆ add_edge() [3/3]

◆ add_elements() [1/2]

◆ add_elements() [2/2]

◆ add_node() [1/3]

◆ add_node() [2/3]

◆ add_node() [3/3]

◆ add_shellface() [1/3]

◆ add_shellface() [2/3]

◆ add_shellface() [3/3]

◆ add_side() [1/3]

◆ add_side() [2/3]

◆ add_side() [3/3]

◆ boundary_id()

◆ boundary_ids() [1/4]

◆ boundary_ids() [2/4]

◆ boundary_ids() [3/4]

◆ boundary_ids() [4/4]

◆ build_active_side_list() [1/2]

◆ build_active_side_list() [2/2]

◆ build_edge_list() [1/2]

◆ build_edge_list() [2/2]

◆ build_node_boundary_ids()

◆ build_node_list() [1/2]

◆ build_node_list() [2/2]

◆ build_node_list_from_side_list()

◆ build_shellface_boundary_ids()

◆ build_shellface_list() [1/2]

◆ build_shellface_list() [2/2]

◆ build_side_boundary_ids()

◆ build_side_list() [1/2]

◆ build_side_list() [2/2]

◆ build_side_list_from_node_list()

◆ clear()

◆ clear_boundary_node_ids()

◆ comm()

◆ copy_boundary_ids()

◆ edge_boundary_ids() [1/2]

◆ edge_boundary_ids() [2/2]

◆ get_boundary_ids()

◆ get_edge_boundary_ids()

◆ get_id_by_name()

◆ get_node_boundary_ids()

◆ get_nodeset_name()

◆ get_nodeset_name_map()

◆ get_shellface_boundary_ids()

◆ get_side_and_node_maps()

◆ get_side_boundary_ids()

◆ get_sideset_name()

◆ get_sideset_name_map()

◆ has_boundary_id() [1/2]

◆ has_boundary_id() [2/2]

◆ n_boundary_conds()

◆ n_boundary_ids() [1/3]

◆ n_boundary_ids() [2/3]

◆ n_boundary_ids() [3/3]

◆ n_edge_boundary_ids()

◆ n_edge_conds()

◆ n_nodeset_conds()

◆ n_processors()

◆ n_shellface_boundary_ids()

◆ n_shellface_conds()

◆ nodeset_name()

◆ operator=()

◆ print_info()

◆ print_summary()