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. More...

#include <boundary_info.h>

Inheritance diagram for libMesh::BoundaryInfo:

[legend]

Public Types
enum	NodeBCTupleSortBy { NodeBCTupleSortBy::NODE_ID, NodeBCTupleSortBy::BOUNDARY_ID, NodeBCTupleSortBy::UNSORTED }

enum	BCTupleSortBy { BCTupleSortBy::ELEM_ID, BCTupleSortBy::SIDE_ID, BCTupleSortBy::BOUNDARY_ID, BCTupleSortBy::UNSORTED }

typedef std::tuple< dof_id_type, boundary_id_type >	NodeBCTuple
	Create a list of (node_id, boundary_id) tuples for all relevant nodes. More...

typedef std::tuple< dof_id_type, unsigned short int, boundary_id_type >	BCTuple
	Create a list of (element_id, side_id, boundary_id) tuples for relevant sides. More...

Public Member Functions
BoundaryInfo &	operator= (const BoundaryInfo &other_boundary_info)
	Copy assignment operator. More...

bool	operator== (const BoundaryInfo &other_boundary_info) const
	This tests for data equality via element ids. More...

bool	operator!= (const BoundaryInfo &other_boundary_info) const

	~BoundaryInfo ()
	Destructor. More...

void	clear ()
	Clears the underlying data structures and restores the object to a pristine state with no data stored. More...

void	regenerate_id_sets ()
	Clears and regenerates the cached sets of ids. More...

void	synchronize_global_id_set ()
	Synchronizes the boundary_ids set on each processor to determine global_boundary_ids. More...

void	sync (UnstructuredMesh &boundary_mesh)
	Generates `boundary_mesh` data structures corresponding to the `mesh` data structures. More...

void	sync (const std::set< boundary_id_type > &requested_boundary_ids, UnstructuredMesh &boundary_mesh)
	Generates `boundary_mesh` data structures corresponding to the `mesh` data structures. More...

void	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. More...

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)
	Suppose we have used sync to create `boundary_mesh`. More...

void	add_elements (const std::set< boundary_id_type > &requested_boundary_ids, UnstructuredMesh &boundary_mesh, bool store_parent_side_ids=false)
	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. More...

void	add_elements (const std::set< boundary_id_type > &requested_boundary_ids, UnstructuredMesh &boundary_mesh, const std::set< subdomain_id_type > &subdomains_relative_to, bool store_parent_side_ids=false)
	Same as the add_elements() function above, but takes a set of subdomains for which the sides must be relative to. More...

void	add_node (const Node *node, const boundary_id_type id)
	Add `Node` `node` with boundary id `id` to the boundary information data structures. More...

void	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. More...

void	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. More...

void	clear_boundary_node_ids ()
	Clears all the boundary information from all of the nodes in the mesh. More...

void	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. More...

void	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. More...

void	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. More...

void	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. More...

void	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. More...

void	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. More...

void	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. More...

void	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. More...

void	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. More...

void	remove (const Node *node)
	Removes the boundary conditions associated with node `node`, if any exist. More...

void	remove (const Elem *elem)
	Removes the boundary conditions associated with element `elem`, if any exist. More...

void	remove_node (const Node *node, const boundary_id_type id)
	Removes boundary id `id` from node `node`, if it exists. More...

void	remove_edge (const Elem *elem, const unsigned short int edge)
	Removes all boundary conditions associated with edge `edge` of element `elem`, if any exist. More...

void	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. More...

void	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. More...

void	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. More...

void	remove_side (const Elem *elem, const unsigned short int side)
	Removes all boundary conditions associated with side `side` of element `elem`, if any exist. More...

void	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. More...

void	clear_stitched_boundary_side_ids (boundary_id_type sideset_id, boundary_id_type other_sideset_id, bool clear_nodeset_data=false)
	Clear sideset information along a stitched mesh interface. More...

void	remove_id (boundary_id_type id, bool global=false)
	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. More...

void	remove_side_id (boundary_id_type id, bool global=false)
	Removes all sides with boundary id `id` from the BoundaryInfo object, removes it from the set of side boundary ids, and removes it from the set of boundary ids if no other boundary type uses it. More...

void	remove_edge_id (boundary_id_type id, bool global=false)
	Removes all edges with boundary id `id` from the BoundaryInfo object, removes it from the set of edge boundary ids, and removes it from the set of boundary ids if no other boundary type uses it. More...

void	remove_shellface_id (boundary_id_type id, bool global=false)
	Removes all shellfaces with boundary id `id` from the BoundaryInfo object, removes it from the set of shellface boundary ids, and removes it from the set of boundary ids if no other boundary type uses it. More...

void	remove_node_id (boundary_id_type id, bool global=false)
	Removes all nodes with boundary id `id` from the BoundaryInfo object, removes it from the set of node boundary ids, and removes it from the set of boundary ids if no other boundary type uses it. More...

void	renumber_id (boundary_id_type old_id, boundary_id_type new_id)
	Changes all entities (nodes, sides, edges, shellfaces) with boundary id `old_id` to instead be labeled by boundary id `new_id`. More...

void	renumber_side_id (boundary_id_type old_id, boundary_id_type new_id)
	Changes all sides with boundary id `old_id` to instead be labeled by boundary id `new_id`. More...

void	renumber_edge_id (boundary_id_type old_id, boundary_id_type new_id)
	Changes all edges with boundary id `old_id` to instead be labeled by boundary id `new_id`. More...

void	renumber_shellface_id (boundary_id_type old_id, boundary_id_type new_id)
	Changes all shellfaces with boundary id `old_id` to instead be labeled by boundary id `new_id`. More...

void	renumber_node_id (boundary_id_type old_id, boundary_id_type new_id)
	Changes all nodes with boundary id `old_id` to instead be labeled by boundary id `new_id`. More...

std::size_t	n_boundary_ids () const

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

void	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`. More...

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

void	edge_boundary_ids (const Elem *const elem, const unsigned short int edge, std::vector< boundary_id_type > &vec_to_fill) 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

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

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

void	side_boundary_ids (const Elem *const elem, std::vector< std::vector< boundary_id_type >> &vec_to_fill) const

void	boundary_ids (const Elem *const elem, const unsigned short int side, std::vector< boundary_id_type > &vec_to_fill) 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

std::vector< unsigned int >	sides_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
	Builds the list of unique node boundary ids. More...

void	build_side_boundary_ids (std::vector< boundary_id_type > &b_ids) const
	Builds the list of unique side boundary ids. More...

void	build_shellface_boundary_ids (std::vector< boundary_id_type > &b_ids) const
	Builds the list of unique shellface boundary ids. More...

void	transfer_boundary_ids_from_children (const Elem *const parent)
	Update parent's boundary id list so that this information is consistent with its children. More...

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

std::vector< NodeBCTuple >	build_node_list (NodeBCTupleSortBy sort_by=NodeBCTupleSortBy::NODE_ID) const

void	build_node_list_from_side_list (const std::set< boundary_id_type > &sideset_list={})
	Adds nodes with boundary ids based on the side's boundary ids they are connected to. More...

void	build_side_list_from_node_list (const std::set< boundary_id_type > &nodeset_list={})
	Adds sides to a sideset if every node on that side are in the same sideset. More...

std::vector< BCTuple >	build_side_list (BCTupleSortBy sort_by=BCTupleSortBy::ELEM_ID) const

std::vector< BCTuple >	build_active_side_list () const
	Create a list of (element_id, side_id, boundary_id) tuples for all relevant active sides. More...

std::vector< BCTuple >	build_edge_list () const
	Create a list of (element_id, edge_id, boundary_id) tuples for all relevant edges. More...

std::vector< BCTuple >	build_shellface_list () const
	Create a list of (element_id, shellface_id, boundary_id) tuples for all relevant shellfaces. More...

void	parallel_sync_side_ids ()
	Synchronize the boundary element side and node across processors. More...

void	parallel_sync_node_ids ()

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

const std::set< boundary_id_type > &	get_global_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_stream=libMesh::out) const
	Prints the boundary information data structure. More...

void	print_summary (std::ostream &out_stream=libMesh::out) const
	Prints a summary of the boundary information. More...

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)

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

std::string &	edgeset_name (boundary_id_type id)

boundary_id_type	get_id_by_name (std::string_view 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

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

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

const std::multimap< const Node *, boundary_id_type > &	get_nodeset_map () const

const std::multimap< const Elem *, std::pair< unsigned short int, boundary_id_type > > &	get_edgeset_map () const

const std::multimap< const Elem *, std::pair< unsigned short int, boundary_id_type > > &	get_sideset_map () const

bool	is_children_on_boundary_side () const

void	allow_children_on_boundary_side (const bool children_on_boundary)
	Whether or not to allow directly setting boundary sides on child elements. More...

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
	Number used for internal use. More...

Protected Member Functions
	BoundaryInfo (MeshBase &m)
	Constructor. More...

void	set_mesh (MeshBase &m)

Protected Attributes
const Parallel::Communicator &	_communicator

Private Member Functions
void	libmesh_assert_valid_multimaps () const
	Helper method for ensuring that our multimaps don't contain entries with duplicate keys and values. More...

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)
	Helper method for finding consistent maps of interior to boundary dof_object ids. More...

Private Attributes
MeshBase *	_mesh
	A pointer to the Mesh this boundary info pertains to. More...

std::multimap< const Node *, boundary_id_type >	_boundary_node_id
	Data structure that maps nodes in the mesh to boundary ids. More...

std::multimap< const Elem *, std::pair< unsigned short int, boundary_id_type > >	_boundary_edge_id
	Data structure that maps edges of elements to boundary ids. More...

std::multimap< const Elem *, std::pair< unsigned short int, boundary_id_type > >	_boundary_shellface_id
	Data structure that maps faces of shell elements to boundary ids. More...

std::multimap< const Elem *, std::pair< unsigned short int, boundary_id_type > >	_boundary_side_id
	Data structure that maps sides of elements to boundary ids. More...

bool	_children_on_boundary

std::set< boundary_id_type >	_boundary_ids
	A collection of user-specified boundary ids for sides, edges, nodes, and shell faces. More...

std::set< boundary_id_type >	_global_boundary_ids
	A collection of user-specified boundary ids for sides, edges, nodes, and shell faces. More...

std::set< boundary_id_type >	_side_boundary_ids
	Set of user-specified boundary IDs for sides only. More...

std::set< boundary_id_type >	_edge_boundary_ids
	Set of user-specified boundary IDs for edges only. More...

std::set< boundary_id_type >	_node_boundary_ids
	Set of user-specified boundary IDs for nodes only. More...

std::set< boundary_id_type >	_shellface_boundary_ids
	Set of user-specified boundary IDs for shellfaces only. More...

std::map< boundary_id_type, std::string >	_ss_id_to_name
	This structure maintains the mapping of named side sets for file formats (Exodus, Gmsh) that support this. More...

std::map< boundary_id_type, std::string >	_ns_id_to_name
	This structure maintains the mapping of named node sets for file formats (Exodus, Gmsh) that support this. More...

std::map< boundary_id_type, std::string >	_es_id_to_name
	This structure maintains the mapping of named edge sets for file formats (Exodus, Gmsh) that support this. More...

Friends
class	MeshBase

Detailed Description

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 Used by the Mesh to keep track of boundary nodes and elements.

Definition at line 57 of file boundary_info.h.

Member Typedef Documentation

◆ BCTuple

typedef std::tuple<dof_id_type, unsigned short int, boundary_id_type> libMesh::BoundaryInfo::BCTuple

Create a list of (element_id, side_id, boundary_id) tuples for relevant sides.

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

The returned vector is sorted by element id by default, but this can be changed by passing SIDE_ID, BOUNDARY_ID, or UNSORTED to this function. Note: choosing UNSORTED is not recommended since the resulting list will potentially be in different orders on different processors when running in parallel.

Definition at line 749 of file boundary_info.h.

◆ NodeBCTuple

typedef std::tuple<dof_id_type, boundary_id_type> libMesh::BoundaryInfo::NodeBCTuple

Create a list of (node_id, boundary_id) tuples for all relevant nodes.

On a ReplicatedMesh this will include all nodes; on a DistributedMesh only semilocal nodes will be included. Note: we could use std::pairs for this, but for consistency with the other build_XYZ_list functions, we're using tuples.

The "sort_by" parameter controls how the resulting list of tuples is sorted. It is possible (but not recommended) to choose UNSORTED, since in that case the resulting vectors will potentially be in different orders on different procs.

Definition at line 715 of file boundary_info.h.

Member Enumeration Documentation

◆ BCTupleSortBy

enum libMesh::BoundaryInfo::BCTupleSortBy

strong

Enumerator
ELEM_ID
SIDE_ID
BOUNDARY_ID
UNSORTED

Definition at line 750 of file boundary_info.h.

750 {ELEM_ID, SIDE_ID, BOUNDARY_ID, UNSORTED};

◆ NodeBCTupleSortBy

enum libMesh::BoundaryInfo::NodeBCTupleSortBy

strong

Enumerator
NODE_ID
BOUNDARY_ID
UNSORTED

Definition at line 716 of file boundary_info.h.

716 {NODE_ID, BOUNDARY_ID, UNSORTED};

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 103 of file boundary_info.C.

                                        :
   ParallelObject(m.comm()),
   _mesh (&m),
   _children_on_boundary(false)
 {
 }

◆ ~BoundaryInfo()

libMesh::BoundaryInfo::~BoundaryInfo ( )

default

Destructor.

Not much to do.

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 3306 of file boundary_info.C.

References _mesh, boundary_ids(), libMesh::ParallelObject::comm(), libMesh::DofObject::id(), invalid_id, libMesh::DofObject::invalid_processor_id, libMesh::Elem::invalid_subdomain_id, libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::make_range(), TIMPI::Communicator::max(), libMesh::MeshTools::n_levels(), libMesh::ParallelObject::n_processors(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_index_range(), libMesh::Elem::node_ref(), libMesh::ParallelObject::processor_id(), libMesh::DofObject::processor_id(), TIMPI::Communicator::set_union(), libMesh::Elem::side_index_range(), and libMesh::Elem::subdomain_id().

Referenced by add_elements(), and sync().

 {
   // We'll use the standard DistributedMesh trick of dividing up id
   // ranges by processor_id to avoid picking duplicate node ids.
   dof_id_type
     next_node_id = first_free_node_id + this->processor_id();
 
   // We have to be careful how we select different element ids on
   // different processors, because we may be adding sides of refined
   // elements and sides of their parents (which are thereby also
   // parents of their sides), but libMesh convention requires (and
   // some libMesh communication code assumes) that parent elements
   // have lower ids than their children.
   //
   // We'll start with temporary ids in a temporary map stratefied by
   // element level, so we can sort by element level after.
   // Make sure we're sorting by ids here, not anything that might
   // differ from processor to processor, so we can do an
   // embarrassingly parallel sort.  This is a serialized data
   // structure, but it's at worst O(N^2/3) so we'll hold off on doing
   // this distributed until someone's benchmark screams at us.
   std::vector
     <std::set<std::pair<dof_id_type, unsigned char>>>
     side_id_set_by_level;
 
   // For avoiding extraneous element side construction
   ElemSideBuilder side_builder;
   // Pull objects out of the loop to reduce heap operations
   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)
           {
             std::size_t n_levels = side_id_set_by_level.size();
             this->comm().max(n_levels);
             side_id_set_by_level.resize(n_levels);
             for (auto l : make_range(n_levels))
               this->comm().set_union(side_id_set_by_level[l]);
           }
           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();
 
           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;
 
       for (auto s : elem->side_index_range())
         {
           bool add_this_side = false;
 
           // Find all the boundary side ids for this Elem side.
           std::vector<boundary_id_type> bcids;
           this->boundary_ids(elem, s, bcids);
 
           for (const boundary_id_type bcid : bcids)
             {
               // if the user wants this id, we want this side
               if (requested_boundary_ids.count(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 (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);
                   auto level = elem->level();
                   if (side_id_set_by_level.size() <= level)
                     side_id_set_by_level.resize(level+1);
                   auto & level_side_id_set = side_id_set_by_level[level];
                   libmesh_assert (!level_side_id_set.count(side_pair));
                   level_side_id_set.insert(side_pair);
                 }
 
               side = &side_builder(*elem, 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: should we renumber node_id_map's image to be contiguous
   // here, rather than waiting for renumbering in mesh preparation to
   // do it later?
 
   // We do need to build up side_id_map here, to handle proper sorting
   // by level.
   if (side_id_map)
     {
       dof_id_type next_elem_id = first_free_elem_id;
       for (auto level : make_range(side_id_set_by_level.size()))
         {
           for (auto side_pair : side_id_set_by_level[level])
             (*side_id_map)[side_pair] = next_elem_id++;
         }
     }
 }

◆ 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 1025 of file boundary_info.C.

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

Referenced by copy_boundary_ids(), main(), libMesh::ExodusII_IO_Helper::read_edge_blocks(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::Elem::swap2boundaryedges(), SystemsTest::testBoundaryProjectCube(), BoundaryInfoTest::testEdgeBoundaryConditions(), BoundaryInfoTest::testSelectiveRenumber(), and WriteEdgesetData::testWriteImpl().

 {
   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 1034 of file boundary_info.C.

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

 {
   libmesh_assert(elem);
 
   // Only add BCs for level-0 elements.
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Only add BCs for edges that exist.
   libmesh_assert_less (edge, elem->n_edges());
 
   libmesh_error_msg_if(id == invalid_id,
                        "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.emplace(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 1064 of file boundary_info.C.

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

 {
   if (ids.empty())
     return;
 
   libmesh_assert(elem);
 
   // Only add BCs for level-0 elements.
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Only add BCs for edges that exist.
   libmesh_assert_less (edge, elem->n_edges());
 
   // 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))
     {
       libmesh_error_msg_if(id == invalid_id,
                            "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.emplace(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,
		bool	store_parent_side_ids = `false`
	)

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 655 of file boundary_info.C.

References libMesh::Elem::invalid_subdomain_id.

Referenced by main(), and 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,
                      store_parent_side_ids);
 }

◆ 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,
		bool	store_parent_side_ids = `false`
	)

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 671 of file boundary_info.C.

 {
   LOG_SCOPE("add_elements()", "BoundaryInfo");
 
   // We're not prepared to mix serial and distributed meshes in this
   // method, so make sure their statuses match from the start.
   //
   // Specifically test *is_serial* here - we can handle a mix of
   // ReplicatedMesh and serialized DistributedMesh.
   libmesh_assert_equal_to(_mesh->is_serial(),
                           boundary_mesh.is_serial());
 
   // If the boundary mesh already has interior pointers pointing at
   // elements in a third mesh then we're in trouble
   libmesh_assert(&boundary_mesh.interior_mesh() == &boundary_mesh ||
                  &boundary_mesh.interior_mesh() == _mesh);
 
   // And now we're going to add interior pointers to elements from
   // this mesh
   boundary_mesh.set_interior_mesh(*_mesh);
 
   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;
 
       for (auto s : elem->side_index_range())
         {
           bool add_this_side = false;
 
           // Find all the boundary side ids for this Elem side.
           std::vector<boundary_id_type> bcids;
           this->boundary_ids(elem, s, bcids);
 
           for (const boundary_id_type bcid : bcids)
             {
               // if the user wants this id, we want this side
               if (requested_boundary_ids.count(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 (requested_boundary_ids.count(invalid_id) &&
               elem->neighbor_ptr(s) == nullptr)
             add_this_side = true;
 
           if (add_this_side)
             sides_to_add.emplace_back(elem->id(), s);
         }
     }
 
 #ifdef LIBMESH_ENABLE_UNIQUE_ID
   unique_id_type old_max_unique_id = boundary_mesh.parallel_max_unique_id();
 #endif
 
   // Add an "extra" integer for storing the side index of the parent
   // Elem which each boundary Elem corresponds to. We do this once
   // before any Elems have been added.
   unsigned int parent_side_index_tag = store_parent_side_ids ?
     boundary_mesh.add_elem_integer("parent_side_index") : libMesh::invalid_uint;
 
   for (const auto & [elem_id, s] : sides_to_add)
     {
       Elem * elem = _mesh->elem_ptr(elem_id);
 
       std::unique_ptr<Elem> side = elem->build_side_ptr(s);
 
       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(std::move(side));
 
       // If requested, new_elem gets an "extra" integer equal to the
       // side id "s" of the interior_parent it corresponds to.
       if (store_parent_side_ids)
         new_elem->set_extra_integer(parent_side_index_tag, s);
 
 #ifdef LIBMESH_ENABLE_AMR
       new_elem->set_refinement_flag(elem->refinement_flag());
       new_elem->set_p_refinement_flag(elem->p_refinement_flag());
 
       // 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);
 
           // 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 (auto v : make_range(new_elem->n_vertices()))
             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);
             }
         }
 
       // Set remote_elem child links if necessary.  Rather than
       // worrying about which interior child corresponds to which side
       // child we'll just set all null links to be remote and we'll
       // rely on our detection of actual semilocal children to
       // overwrite the links that shouldn't be remote.
       if (elem->has_children())
         for (auto c : make_range(elem->n_children()))
           if (elem->child_ptr(c) == remote_elem &&
               elem->is_child_on_side(c, s))
             {
               for (auto sc : make_range(new_elem->n_children()))
                 if (!new_elem->raw_child_ptr(sc))
                   new_elem->add_child
                     (const_cast<RemoteElem*>(remote_elem), sc);
             }
 #endif
 
       new_elem->set_interior_parent (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 or nodes, unless we're doing everything the same on
   // every processor.
   if (!boundary_mesh.is_replicated())
     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 954 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_cube(), libMesh::MeshTools::Generation::build_extrusion(), build_node_list_from_side_list(), main(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::GmshIO::read_mesh(), libMesh::CheckpointIO::read_nodesets(), libMesh::XdrIO::read_serialized_nodesets(), libMesh::UnstructuredMesh::stitching_helper(), sync(), and SystemsTest::testBoundaryProjectCube().

 {
   libmesh_error_msg_if(id == invalid_id,
                        "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.emplace(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 937 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.
   libmesh_error_msg_if(!node_ptr,
                        "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 974 of file boundary_info.C.

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

 {
   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))
     {
       libmesh_error_msg_if(id == invalid_id,
                            "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.emplace(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 1118 of file boundary_info.C.

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

Referenced by copy_boundary_ids(), libMesh::ExodusII_IO::read(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::UnstructuredMesh::stitching_helper(), and BoundaryInfoTest::testShellFaceConstraints().

 {
   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 1127 of file boundary_info.C.

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

 {
   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);
 
   libmesh_error_msg_if(id == invalid_id,
                        "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.emplace(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 1157 of file boundary_info.C.

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

 {
   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))
     {
       libmesh_error_msg_if(id == invalid_id,
                            "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.emplace(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 1210 of file boundary_info.C.

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

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(), DisjointNeighborTest::build_four_disjoint_elems(), BoundaryMesh0DTest::build_mesh(), BoundaryMeshTest::build_mesh(), build_side_list_from_node_list(), DisjointNeighborTest::build_split_mesh_with_interface(), DisjointNeighborTest::build_two_disjoint_elems(), copy_boundary_ids(), libMesh::TriangleWrapper::copy_tri_to_mesh(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::flatten(), libMesh::UNVIO::groups_in(), libMesh::Poly2TriTriangulator::insert_refinement_points(), main(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::CheckpointIO::read_bcs(), libMesh::GmshIO::read_mesh(), libMesh::XdrIO::read_serialized_bcs_helper(), libMesh::SimplexRefiner::refine_via_edges(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::Elem::swap2boundarysides(), AllTriTest::test_helper_c0polyhedron(), AllTriTest::testAllTriC0PolygonOctagon(), BoundaryInfoTest::testBoundaryIDs(), BoundaryInfoTest::testBoundaryOnChildrenBoundaryIDs(), BoundaryInfoTest::testBoundaryOnChildrenBoundarySides(), BoundaryInfoTest::testBoundaryOnChildrenElementsRefineCoarsen(), BoundaryInfoTest::testBoundaryOnChildrenErrors(), DisjointNeighborTest::testDisjointNeighborConflictError(), BoundaryInfoTest::testInternalBoundary(), PeriodicBCTest::testPeriodicBC(), DisjointNeighborTest::testStitchCrossMesh(), transfer_boundary_ids_from_children(), libMesh::NetGenMeshInterface::triangulate(), and libMesh::Poly2TriTriangulator::triangulate_current_points().

 {
   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 1219 of file boundary_info.C.

References _boundary_ids, _boundary_side_id, _children_on_boundary, _side_boundary_ids, libMesh::as_range(), boundary_ids(), invalid_id, libMesh::Elem::level(), libMesh::libmesh_assert(), and libMesh::Elem::n_sides().

 {
   libmesh_assert(elem);
 
   // Only add BCs for sides that exist.
   libmesh_assert_less (side, elem->n_sides());
 
   libmesh_error_msg_if(id == invalid_id, "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;
 
 #ifdef LIBMESH_ENABLE_AMR
   // Users try to mark boundary on child elements
   // If this happens, we will allow users to remove
   // side from child elements as well
   if (elem->level())
   {
     _children_on_boundary = true;
 
     // Here we have to stop and check if we already have this boundary defined on the
     // parent (if yes, no need to add)
     std::vector<boundary_id_type> bd_ids;
     this->boundary_ids(elem,side,bd_ids);
 
     if(std::find(bd_ids.begin(), bd_ids.end(), id) != bd_ids.end())
       libmesh_not_implemented_msg("Trying to add boundary ID "
                                   + std::to_string(id)
                                   + " which already exists on the ancestors.");
   }
 #endif
 
   _boundary_side_id.emplace(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 1265 of file boundary_info.C.

References _boundary_ids, _boundary_side_id, _children_on_boundary, _side_boundary_ids, libMesh::as_range(), boundary_ids(), invalid_id, libMesh::Elem::level(), libMesh::libmesh_assert(), and libMesh::Elem::n_sides().

 {
   if (ids.empty())
     return;
 
   libmesh_assert(elem);
 
   // Only add BCs for sides that exist.
   libmesh_assert_less (side, elem->n_sides());
 
 #ifdef LIBMESH_ENABLE_AMR
   // Users try to mark boundary on child elements
   // If this happens, we will allow users to remove
   // side from child elements as well
   if (elem->level())
   {
     _children_on_boundary = true;
 
     // Here we have to stop and check if we already have this boundary defined on the
     // parent (if yes, no need to add)
     std::vector<boundary_id_type> bd_ids;
     this->boundary_ids(elem,side,bd_ids);
 
     for (const auto id : ids)
       if(std::find(bd_ids.begin(), bd_ids.end(), id) != bd_ids.end())
         libmesh_not_implemented_msg("Trying to add boundary ID "
                                     + std::to_string(id)
                                     + " which already exists on the ancestors.");
   }
 #endif
 
   // 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))
     {
       libmesh_error_msg_if(id == invalid_id,
                            "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.emplace(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
     }
 }

◆ allow_children_on_boundary_side()

void libMesh::BoundaryInfo::allow_children_on_boundary_side ( const bool children_on_boundary )

inline

Whether or not to allow directly setting boundary sides on child elements.

Definition at line 941 of file boundary_info.h.

References _children_on_boundary.

Referenced by BoundaryInfoTest::testBoundaryOnChildrenBoundaryIDs(), and BoundaryInfoTest::testBoundaryOnChildrenErrors().

942 { _children_on_boundary = children_on_boundary; }

libMesh::BoundaryInfo::_children_on_boundary

bool _children_on_boundary

Definition: boundary_info.h:1007

◆ boundary_ids() [1/2]

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.

Definition at line 1348 of file boundary_info.C.

References _boundary_node_id, and libMesh::as_range().

Referenced by _find_id_maps(), add_elements(), add_side(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), assemble_elasticity(), AssemblyA0::boundary_assembly(), AssemblyA1::boundary_assembly(), AssemblyA2::boundary_assembly(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_extrusion(), build_node_list_from_side_list(), libMesh::FEGenericBase< FEOutputType< T >::type >::compute_periodic_constraints(), libMesh::UnstructuredMesh::create_submesh(), libMesh::MeshTools::Modification::flatten(), has_boundary_id(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::Poly2TriTriangulator::is_refine_boundary_allowed(), main(), libMesh::TriangulatorInterface::MeshedHole::MeshedHole(), n_boundary_ids(), libMesh::VariationalSmootherConstraint::nodes_share_boundary_id(), libMesh::GhostPointNeighbors::operator()(), libMesh::BoundaryProjectSolution::operator()(), operator==(), libMesh::SimplexRefiner::refine_via_edges(), remove_side(), libMesh::FEMContext::side_boundary_ids(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::Elem::swap2boundarysides(), sync(), ElemTest< elem_type >::test_flip(), ElemTest< elem_type >::test_orient(), ElemTest< elem_type >::test_orient_elements(), BoundaryInfoTest::testBoundaryIDs(), BoundaryInfoTest::testBoundaryOnChildrenBoundaryIDs(), SystemsTest::testBoundaryProjectCube(), MeshInputTest::testExodusIGASidesets(), libMesh::XdrIO::write_serialized_bcs_helper(), and libMesh::XdrIO::write_serialized_nodesets().

 {
   // 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() [2/2]

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.

Definition at line 1637 of file boundary_info.C.

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

 {
   libmesh_assert(elem);
 
   // Only query BCs for sides that exist.
   libmesh_assert_less (side, elem->n_sides());
 
   // Clear out any previous contents
   vec_to_fill.clear();
 
   // In most cases only level-0 elements store BCs.
   // In certain applications (such as time-dependent domains), however, children
   // need to store BCs too. This case is covered with the _children_on_boundary
   // flag.
   const Elem * searched_elem = elem;
 
 #ifdef LIBMESH_ENABLE_AMR
 
   if (elem->level() != 0)
   {
     // If we have children on the boundaries, we need to search for boundary IDs on the
     // child and its ancestors too if they share the side.
     if (_children_on_boundary)
     {
       // Loop over ancestors to check if they have boundary ids on the same side
       while (searched_elem)
       {
         for (const auto & pr : as_range(_boundary_side_id.equal_range(searched_elem)))
           // Here we need to check if the boundary id already exists
           if (pr.second.first == side &&
               std::find(vec_to_fill.begin(), vec_to_fill.end(), pr.second.second) ==
               vec_to_fill.end())
             vec_to_fill.push_back(pr.second.second);
 
 
         const Elem * parent = searched_elem->parent();
         // If the parent doesn't exist or if the child is not on the correct side of the
         // parent we are done checking the ancestors
         if (!parent || parent->is_child_on_side(parent->which_child_am_i(searched_elem), side) == false)
           return;
 
         searched_elem = parent;
       }
 
       return;
     }
 
     // If we don't have children on boundaries and we are on an external boundary,
     // we just look for the top parent
     if (elem->neighbor_ptr(side) == nullptr)
       searched_elem = elem->top_parent();
     // Otherwise we loop over the ancestors and check if they have a different BC for us
     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()

std::vector< BoundaryInfo::BCTuple > libMesh::BoundaryInfo::build_active_side_list ( ) const

Create a list of (element_id, side_id, boundary_id) tuples for all relevant active sides.

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

Definition at line 3026 of file boundary_info.C.

References _boundary_side_id.

 {
   std::vector<BCTuple> bc_triples;
   bc_triples.reserve(_boundary_side_id.size());
 
   for (const auto & [elem, id_pair] : _boundary_side_id)
     {
       // Don't add remote sides
       if (elem->is_remote())
         continue;
 
       // Loop over the sides of possible children
       std::vector<const Elem *> family;
 #ifdef LIBMESH_ENABLE_AMR
       elem->active_family_tree_by_side(family, id_pair.first);
 #else
       family.push_back(elem);
 #endif
 
       // Populate the list items
       for (const auto & f : family)
         bc_triples.emplace_back(f->id(), id_pair.first, id_pair.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()

std::vector< BoundaryInfo::BCTuple > libMesh::BoundaryInfo::build_edge_list ( ) const

Create a list of (element_id, edge_id, boundary_id) tuples for all relevant edges.

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

Definition at line 3059 of file boundary_info.C.

References _boundary_edge_id.

Referenced by libMesh::UnstructuredMesh::stitching_helper(), MeshInputTest::testLowOrderEdgeBlocks(), WriteEdgesetData::testWriteImpl(), and libMesh::ExodusII_IO_Helper::write_elements().

 {
   std::vector<BCTuple> bc_triples;
   bc_triples.reserve(_boundary_edge_id.size());
 
   for (const auto & [elem, id_pair] : _boundary_edge_id)
     bc_triples.emplace_back(elem->id(), id_pair.first, id_pair.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 2502 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()

std::vector< BoundaryInfo::NodeBCTuple > libMesh::BoundaryInfo::build_node_list ( NodeBCTupleSortBy sort_by = NodeBCTupleSortBy::NODE_ID ) const

Definition at line 2683 of file boundary_info.C.

References _boundary_node_id, BOUNDARY_ID, and NODE_ID.

Referenced by libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::UnstructuredMesh::stitching_helper(), BoundaryInfoTest::testBuildNodeListFromSideList(), WriteNodesetData::testWriteImpl(), libMesh::CheckpointIO::write(), and libMesh::ExodusII_IO_Helper::write_nodesets().

 {
   std::vector<NodeBCTuple> bc_tuples;
   bc_tuples.reserve(_boundary_node_id.size());
 
   for (const auto & [node, bid] : _boundary_node_id)
     bc_tuples.emplace_back(node->id(), bid);
 
   // This list is currently in memory address (arbitrary) order, so
   // sort, using the specified ordering, to make it consistent on all procs.
   if (sort_by == NodeBCTupleSortBy::NODE_ID)
     std::sort(bc_tuples.begin(), bc_tuples.end());
   else if (sort_by == NodeBCTupleSortBy::BOUNDARY_ID)
     std::sort(bc_tuples.begin(), bc_tuples.end(),
               [](const NodeBCTuple & left, const NodeBCTuple & right)
               {return std::get<1>(left) < std::get<1>(right);});
 
   return bc_tuples;
 }

◆ build_node_list_from_side_list()

void libMesh::BoundaryInfo::build_node_list_from_side_list ( const std::set< boundary_id_type > & sideset_list = {} )

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

Parameters

sideset_list sidesets to build nodesets from. If empty (default), builds from all existing sidesets

Definition at line 2705 of file boundary_info.C.

References _boundary_side_id, _mesh, libMesh::Elem::active_family_tree_by_side(), add_node(), boundary_ids(), libMesh::ParallelObject::comm(), libMesh::index_range(), libMesh::MeshBase::is_serial(), libMesh::Elem::node_id(), libMesh::Elem::node_index_range(), libMesh::Elem::node_ptr(), libMesh::MeshBase::node_ptr(), libMesh::ParallelObject::processor_id(), and libMesh::DofObject::processor_id().

Referenced by BoundaryInfoTest::testBuildNodeListFromSideList(), and WriteNodesetData::testWriteImpl().

 {
   // 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;
   typedef std::vector<std::pair<dof_id_type, boundary_id_type>> vec_type;
 
   const processor_id_type my_proc_id = this->processor_id();
   std::unordered_map<processor_id_type, set_type> nodes_to_push;
   std::unordered_map<processor_id_type, vec_type> node_vecs_to_push;
 
   // For avoiding extraneous element side construction
   ElemSideBuilder side_builder;
   // Pull objects out of the loop to reduce heap operations
   const Elem * side;
 
   // Loop over the side list
   for (const auto & [elem, id_pair] : _boundary_side_id)
     {
       // Don't add remote sides
       if (elem->is_remote())
         continue;
 
       auto [sidenum, bcid] = id_pair;
 
       if (!sideset_list.empty() && !sideset_list.count(bcid))
         continue;
 
       // Need to loop over the sides of any possible children
       std::vector<const Elem *> family;
 #ifdef LIBMESH_ENABLE_AMR
       elem->active_family_tree_by_side (family, sidenum);
 #else
       family.push_back(elem);
 #endif
 
       for (const auto & cur_elem : family)
         {
           side = &side_builder(*cur_elem, sidenum);
 
           // Add each node node on the side with the side's boundary id
           for (auto i : side->node_index_range())
             {
               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].emplace(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.
 
   for (auto & [proc_id, s] : nodes_to_push)
     {
       node_vecs_to_push[proc_id].assign(s.begin(), s.end());
       s.clear();
     }
 
   auto nodes_action_functor =
     [this]
     (processor_id_type,
      const vec_type & received_nodes)
     {
       for (const auto & [dof_id, bndry_id] : received_nodes)
         this->add_node(_mesh->node_ptr(dof_id), bndry_id);
     };
 
   Parallel::push_parallel_vector_data
     (this->comm(), node_vecs_to_push, nodes_action_functor);
 
   // At this point we should know all the BCs for our own nodes; now
   // we need BCs for ghost nodes.
   std::unordered_map<processor_id_type, std::vector<dof_id_type>>
     node_ids_requested;
 
   // 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<boundary_id_type> datum_type;
 
   auto node_bcid_gather_functor =
     [this]
     (processor_id_type,
      const std::vector<dof_id_type> & ids,
      std::vector<datum_type> & data)
     {
       const std::size_t query_size = ids.size();
       data.resize(query_size);
 
       for (std::size_t i=0; i != query_size; ++i)
         this->boundary_ids(_mesh->node_ptr(ids[i]), data[i]);
     };
 
   auto node_bcid_action_functor =
     [this]
     (processor_id_type,
      const std::vector<dof_id_type> & ids,
      const std::vector<datum_type> & data)
     {
       for (auto i : index_range(ids))
         this->add_node(_mesh->node_ptr(ids[i]), data[i]);
     };
 
   datum_type * datum_type_ex = nullptr;
   Parallel::pull_parallel_vector_data
     (this->comm(), node_ids_requested, node_bcid_gather_functor,
      node_bcid_action_functor, datum_type_ex);
 }

◆ 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 2530 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()

std::vector< BoundaryInfo::BCTuple > libMesh::BoundaryInfo::build_shellface_list ( ) const

Create a list of (element_id, shellface_id, boundary_id) tuples for all relevant shellfaces.

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

Definition at line 3076 of file boundary_info.C.

References _boundary_shellface_id.

Referenced by libMesh::UnstructuredMesh::stitching_helper(), and libMesh::ExodusII_IO_Helper::write_sidesets().

 {
   std::vector<BCTuple> bc_triples;
   bc_triples.reserve(_boundary_shellface_id.size());
 
   for (const auto & [elem, id_pair] : _boundary_shellface_id)
     bc_triples.emplace_back(elem->id(), id_pair.first, id_pair.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 2516 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()

std::vector< BoundaryInfo::BCTuple > libMesh::BoundaryInfo::build_side_list ( BCTupleSortBy sort_by = BCTupleSortBy::ELEM_ID ) const

Definition at line 2997 of file boundary_info.C.

References _boundary_side_id, BOUNDARY_ID, ELEM_ID, and SIDE_ID.

Referenced by libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::UnstructuredMesh::stitching_helper(), BoundaryInfoTest::testBuildSideListFromNodeList(), BoundaryInfoTest::testMesh(), MeshTriangulationTest::testPoly2TriHolesInteriorRefinedBase(), BoundaryInfoTest::testRenumber(), WriteEdgesetData::testWriteImpl(), WriteSidesetData::testWriteImpl(), libMesh::FroIO::write(), libMesh::CheckpointIO::write(), libMesh::GmshIO::write_mesh(), and libMesh::ExodusII_IO_Helper::write_sidesets().

 {
   std::vector<BCTuple> bc_triples;
   bc_triples.reserve(_boundary_side_id.size());
 
   for (const auto & [elem, id_pair] : _boundary_side_id)
     bc_triples.emplace_back(elem->id(), id_pair.first, id_pair.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.
   if (sort_by == BCTupleSortBy::ELEM_ID)
     std::sort(bc_triples.begin(), bc_triples.end());
   else if (sort_by == BCTupleSortBy::SIDE_ID)
     std::sort(bc_triples.begin(), bc_triples.end(),
               [](const BCTuple & left, const BCTuple & right)
               {return std::get<1>(left) < std::get<1>(right);});
   else if (sort_by == BCTupleSortBy::BOUNDARY_ID)
     std::sort(bc_triples.begin(), bc_triples.end(),
               [](const BCTuple & left, const BCTuple & right)
               {return std::get<2>(left) < std::get<2>(right);});
 
   return bc_triples;
 }

◆ build_side_list_from_node_list()

void libMesh::BoundaryInfo::build_side_list_from_node_list ( const std::set< boundary_id_type > & nodeset_list = {} )

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

Parameters

nodeset_list nodesets to build sidesets from. If empty (default), builds from all existing sidesets

Definition at line 2946 of file boundary_info.C.

References _boundary_node_id, _mesh, add_side(), libMesh::as_range(), libMesh::Elem::n_nodes(), libMesh::Elem::node_ref_range(), nodeset_name(), libMesh::out, and sideset_name().

Referenced by libMesh::AbaqusIO::read(), and BoundaryInfoTest::testBuildSideListFromNodeList().

 {
   // 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;
     }
 
   // For avoiding extraneous element side construction
   ElemSideBuilder side_builder;
   // Pull objects out of the loop to reduce heap operations
   const Elem * side_elem;
 
   for (const auto & elem : _mesh->active_element_ptr_range())
     for (auto side : elem->side_index_range())
       {
         side_elem = &side_builder(*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)))
             if (nodeset_list.empty() || nodeset_list.count(pr.second))
               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 345 of file boundary_info.C.

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

Referenced by operator=(), and libMesh::Poly2TriTriangulator::triangulate_current_points().

 {
   _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();
   _ss_id_to_name.clear();
   _ns_id_to_name.clear();
   _es_id_to_name.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 1020 of file boundary_info.C.

References _boundary_node_id.

 {
   _boundary_node_id.clear();
 }

◆ clear_stitched_boundary_side_ids()

void libMesh::BoundaryInfo::clear_stitched_boundary_side_ids	(	boundary_id_type	sideset_id,
		boundary_id_type	other_sideset_id,
		bool	clear_nodeset_data = `false`
	)

Clear sideset information along a stitched mesh interface.

Parameters

sideset_id	A sideset on one side of the stitched mesh interface
other_sideset_id	The sideset on the other side of the stitched mesh interface
clear_nodeset_data	Whether to clear boundary information for the nodes along the stitched mesh interface

Definition at line 3483 of file boundary_info.C.

References _boundary_side_id, invalid_id, libmesh_assert_valid_multimaps(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::node_ptr(), libMesh::Elem::nodes_on_side(), regenerate_id_sets(), remove_node(), and libMesh::Elem::which_neighbor_am_i().

Referenced by libMesh::UnstructuredMesh::stitching_helper().

 {
   auto end_it = _boundary_side_id.end();
   auto it = _boundary_side_id.begin();
 
   // This predicate checks to see whether the pred_pr triplet's boundary ID matches sideset_id
   // (other_sideset_id) *and* whether there is a boundary information triplet on the other side of
   // the face whose boundary ID matches the other_sideset_id (sideset_id). We return a pair where
   // first is a boolean indicating our condition is true or false, and second is an iterator to the
   // neighboring triplet if our condition is true
   auto predicate =
       [sideset_id, other_sideset_id](
           const std::pair<const Elem *, std::pair<unsigned short int, boundary_id_type>> & pred_pr,
           const std::multimap<const Elem *, std::pair<unsigned short int, boundary_id_type>> &
               pred_container) {
         const Elem & elem = *pred_pr.first;
         const auto elem_side = pred_pr.second.first;
         const Elem * const other_elem = elem.neighbor_ptr(elem_side);
         if (!other_elem)
           return std::make_pair(false, pred_container.end());
 
         const auto elem_side_bnd_id = pred_pr.second.second;
         auto other_elem_side_bnd_id = BoundaryInfo::invalid_id;
         if (elem_side_bnd_id == sideset_id)
           other_elem_side_bnd_id = other_sideset_id;
         else if (elem_side_bnd_id == other_sideset_id)
           other_elem_side_bnd_id = sideset_id;
         else
           return std::make_pair(false, pred_container.end());
 
         const auto other_elem_side = other_elem->which_neighbor_am_i(&elem);
         const typename std::decay<decltype(pred_container)>::type::value_type other_sideset_info(
             other_elem, std::make_pair(other_elem_side, other_elem_side_bnd_id));
         auto other_range = pred_container.equal_range(other_elem);
         libmesh_assert_msg(
             other_range.first != other_range.second,
             "No matching sideset information for other element in boundary information");
         auto other_it = std::find(other_range.first, other_range.second, other_sideset_info);
         libmesh_assert_msg(
             other_it != pred_container.end(),
             "No matching sideset information for other element in boundary information");
         return std::make_pair(true, other_it);
       };
 
   for (; it != end_it;)
   {
     auto pred_result = predicate(*it, _boundary_side_id);
     if (pred_result.first)
     {
       // First erase associated nodeset information.  Do it from both
       // sides, so we get any higher-order nodes if we're looking at
       // them from a lower-order side, and so we only remove the two
       // boundary ids used for stitching.
       if (clear_nodeset_data)
       {
         const Elem & elem = *it->first;
         const Elem & neigh = *pred_result.second->first;
         const auto elem_side = it->second.first;
         const boundary_id_type neigh_side = pred_result.second->second.first;
         const auto elem_bcid = it->second.second;
         const boundary_id_type neigh_bcid = pred_result.second->second.second;
 
         for (const auto local_node_num : elem.nodes_on_side(elem_side))
           this->remove_node(elem.node_ptr(local_node_num), elem_bcid);
 
         for (const auto local_node_num : neigh.nodes_on_side(neigh_side))
           this->remove_node(neigh.node_ptr(local_node_num), neigh_bcid);
       }
 
       // Now erase the sideset information for our element and its
       // neighbor, together.  This is safe since a multimap doesn't
       // invalidate iterators.
       _boundary_side_id.erase(pred_result.second);
       it = _boundary_side_id.erase(it);
     }
     else
       ++it;
   }
 
   // Removing stitched-away boundary ids might have removed an id
   // *entirely*, so we need to recompute boundary id sets to check
   // for that.
   this->regenerate_id_sets();
   this->libmesh_assert_valid_multimaps();
 }

◆ comm()

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

inlineinherited

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

Definition at line 97 of file parallel_object.h.

References libMesh::ParallelObject::_communicator.

98 { return _communicator; }

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:120

◆ 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 1756 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().

 {
   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()

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.

Definition at line 1368 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::libmesh_assert(), libMesh::Elem::n_edges(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::parent(), libMesh::Elem::side_index_range(), libMesh::Elem::top_parent(), and libMesh::Elem::which_child_am_i().

Referenced by n_edge_boundary_ids(), libMesh::BoundaryProjectSolution::operator()(), operator==(), libMesh::UnstructuredMesh::stitching_helper(), libMesh::Elem::swap2boundaryedges(), and libMesh::XdrIO::write_serialized_bcs_helper().

 {
   libmesh_assert(elem);
 
   // Clear out any previous contents
   vec_to_fill.clear();
 
   // Only query BCs for edges that exist.
   libmesh_assert_less (edge, elem->n_edges());
 
   // 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);
 }

◆ edgeset_name()

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

Returns: A writable reference to an optional edgeset name.

Definition at line 3277 of file boundary_info.C.

References _es_id_to_name.

Referenced by libMesh::ExodusII_IO_Helper::read_edge_blocks(), BoundaryInfoTest::testSelectiveRenumber(), and WriteEdgesetData::testWriteImpl().

 {
   return _es_id_to_name[id];
 }

◆ 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.

Code that wishes to access boundary ids on all parts of the mesh, including non-local parts, should call get_global_boundary_ids

Definition at line 794 of file boundary_info.h.

References _boundary_ids.

Referenced by libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::UnstructuredMesh::stitching_helper(), MeshInputTest::testExodusIGASidesets(), BoundaryInfoTest::testMesh(), BoundaryInfoTest::testRenumber(), BoundaryInfoTest::testSelectiveRenumber(), and libMesh::FroIO::write().

795 { return _boundary_ids; }

libMesh::BoundaryInfo::_boundary_ids

std::set< boundary_id_type > _boundary_ids

A collection of user-specified boundary ids for sides, edges, nodes, and shell faces.

Definition: boundary_info.h:1018

◆ 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 816 of file boundary_info.h.

References _edge_boundary_ids.

Referenced by libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::MeshBase::get_info(), libMesh::ExodusII_IO_Helper::initialize(), BoundaryInfoTest::testSelectiveRenumber(), and WriteEdgesetData::testWriteImpl().

817 { return _edge_boundary_ids; }

libMesh::BoundaryInfo::_edge_boundary_ids

std::set< boundary_id_type > _edge_boundary_ids

Set of user-specified boundary IDs for edges only.

Definition: boundary_info.h:1052

◆ get_edgeset_map()

const std::multimap<const Elem *, std::pair<unsigned short int, boundary_id_type> >& libMesh::BoundaryInfo::get_edgeset_map ( ) const

inline

Returns: A const reference to the edgeset map.

Definition at line 923 of file boundary_info.h.

References _boundary_edge_id.

924 { return _boundary_edge_id; }

libMesh::BoundaryInfo::_boundary_edge_id

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

Data structure that maps edges of elements to boundary ids.

Definition: boundary_info.h:984

◆ get_edgeset_name()

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

Returns: A const reference to an optional edgeset name.

Definition at line 3266 of file boundary_info.C.

References _es_id_to_name.

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

 {
   static const std::string empty_string;
   if (const auto it = _es_id_to_name.find(id);
       it == _es_id_to_name.end())
     return empty_string;
   else
     return it->second;
 }

◆ get_edgeset_name_map()

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

inline

Definition at line 905 of file boundary_info.h.

References _es_id_to_name.

Referenced by libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshBase::get_info(), and libMesh::UnstructuredMesh::stitching_helper().

906 { return _es_id_to_name; }

libMesh::BoundaryInfo::_es_id_to_name

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

This structure maintains the mapping of named edge sets for file formats (Exodus, Gmsh) that support ...

Definition: boundary_info.h:1102

◆ get_global_boundary_ids()

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

Returns: A set of the boundary ids which exist globally on the mesh. Relies on the mesh being prepared

Definition at line 3572 of file boundary_info.C.

References _global_boundary_ids, _mesh, libMesh::MeshBase::is_prepared(), and libMesh::libmesh_assert().

Referenced by MeshStitchTest::renameAndShift().

 {
   libmesh_assert(_mesh && _mesh->is_prepared());
   return _global_boundary_ids;
 }

◆ get_id_by_name()

boundary_id_type libMesh::BoundaryInfo::get_id_by_name ( std::string_view name ) const

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

Definition at line 3282 of file boundary_info.C.

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

 {
   // Search sidesets
   for (const auto & [ss_id, ss_name] : _ss_id_to_name)
     if (ss_name == name)
       return ss_id;
 
   // Search nodesets
   for (const auto & [ns_id, ns_name] : _ns_id_to_name)
     if (ns_name == name)
       return ns_id;
 
   // Search edgesets
   for (const auto & [es_id, es_name] : _es_id_to_name)
     if (es_name == name)
       return es_id;
 
   // If we made it here without returning, we don't have a sideset,
   // nodeset, or edgeset 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 832 of file boundary_info.h.

References _node_boundary_ids.

Referenced by libMesh::DofMap::check_dirichlet_bcid_consistency(), libMesh::Nemesis_IO_Helper::compute_num_global_nodesets(), libMesh::MeshBase::get_info(), MeshStitchTest::testBoundaryInfo(), and BoundaryInfoTest::testSelectiveRenumber().

833 { return _node_boundary_ids; }

libMesh::BoundaryInfo::_node_boundary_ids

std::set< boundary_id_type > _node_boundary_ids

Set of user-specified boundary IDs for nodes only.

Definition: boundary_info.h:1063

◆ get_nodeset_map()

const std::multimap<const Node *, boundary_id_type>& libMesh::BoundaryInfo::get_nodeset_map ( ) const

inline

Returns: A const reference to the nodeset map.

Definition at line 917 of file boundary_info.h.

References _boundary_node_id.

918 { return _boundary_node_id; }

libMesh::BoundaryInfo::_boundary_node_id

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

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

Definition: boundary_info.h:976

◆ 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 3251 of file boundary_info.C.

References _ns_id_to_name.

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

 {
   static const std::string empty_string;
   if (const auto it = _ns_id_to_name.find(id);
       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 897 of file boundary_info.h.

References _ns_id_to_name.

Referenced by libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshBase::get_info(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::UnstructuredMesh::stitching_helper(), MeshStitchTest::testBoundaryInfo(), and libMesh::ExodusII_IO_Helper::write_nodesets().

898 { return _ns_id_to_name; }

libMesh::BoundaryInfo::_ns_id_to_name

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

This structure maintains the mapping of named node sets for file formats (Exodus, Gmsh) that support ...

Definition: boundary_info.h:1093

◆ 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 825 of file boundary_info.h.

References _shellface_boundary_ids.

826 { return _shellface_boundary_ids; }

libMesh::BoundaryInfo::_shellface_boundary_ids

std::set< boundary_id_type > _shellface_boundary_ids

Set of user-specified boundary IDs for shellfaces only.

Definition: boundary_info.h:1075

◆ 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 603 of file boundary_info.C.

References libMesh::Elem::interior_parent(), libMesh::Elem::node_id(), libMesh::TensorTools::norm(), libMesh::Real, libMesh::Elem::side_index_range(), and libMesh::Elem::vertex_average().

 {
   LOG_SCOPE("get_side_and_node_maps()", "BoundaryInfo");
 
   node_id_map.clear();
   side_id_map.clear();
 
   // For building element sides without extraneous allocation
   ElemSideBuilder side_builder;
   // Pull objects out of the loop to reduce heap operations
   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 distance between average vertex location 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_side = &side_builder(*interior_parent, side);
           Real va_distance = (boundary_elem->vertex_average() - interior_parent_side->vertex_average()).norm();
 
           if (va_distance < (tolerance * boundary_elem->hmin()))
             {
               interior_parent_side_index = cast_int<unsigned char>(side);
               found_matching_sides = true;
               break;
             }
         }
 
       libmesh_error_msg_if(!found_matching_sides, "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 807 of file boundary_info.h.

References _side_boundary_ids.

Referenced by libMesh::MeshTools::Generation::build_extrusion(), libMesh::Nemesis_IO_Helper::compute_num_global_sidesets(), libMesh::MeshBase::get_info(), MeshStitchTest::testBoundaryInfo(), and BoundaryInfoTest::testSelectiveRenumber().

808 { return _side_boundary_ids; }

libMesh::BoundaryInfo::_side_boundary_ids

std::set< boundary_id_type > _side_boundary_ids

Set of user-specified boundary IDs for sides only.

Definition: boundary_info.h:1041

◆ get_sideset_map()

const std::multimap<const Elem *, std::pair<unsigned short int, boundary_id_type> >& libMesh::BoundaryInfo::get_sideset_map ( ) const

inline

Returns: A const reference to the sideset map.

Definition at line 929 of file boundary_info.h.

References _boundary_side_id.

930 { return _boundary_side_id; }

libMesh::BoundaryInfo::_boundary_side_id

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

Data structure that maps sides of elements to boundary ids.

Definition: boundary_info.h:1000

◆ 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 3235 of file boundary_info.C.

References _ss_id_to_name.

Referenced by libMesh::UnstructuredMesh::stitching_helper(), and libMesh::ExodusII_IO_Helper::write_sidesets().

 {
   static const std::string empty_string;
   if (const auto it = _ss_id_to_name.find(id);
       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 889 of file boundary_info.h.

References _ss_id_to_name.

Referenced by libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshBase::get_info(), libMesh::ExodusII_IO_Helper::initialize(), libMesh::UnstructuredMesh::stitching_helper(), MeshStitchTest::testBoundaryInfo(), MeshInputTest::testGmshBCIDOverlap(), and libMesh::ExodusII_IO_Helper::write_sidesets().

890 { return _ss_id_to_name; }

libMesh::BoundaryInfo::_ss_id_to_name

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

This structure maintains the mapping of named side sets for file formats (Exodus, Gmsh) that support ...

Definition: boundary_info.h:1084

◆ 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 1336 of file boundary_info.C.

References _boundary_node_id, and libMesh::as_range().

Referenced by LinearElasticity::assemble(), assemble_elasticity(), assemble_poisson(), AssemblyF0::boundary_assembly(), AssemblyF1::boundary_assembly(), AssemblyF2::boundary_assembly(), libMesh::UnstructuredMesh::find_neighbors(), libMesh::FEMContext::has_side_boundary_id(), LinearElasticityWithContact::initialize_contact_load_paths(), main(), AugmentSparsityOnInterface::mesh_reinit(), operator==(), SolidSystem::side_time_derivative(), libMesh::UnstructuredMesh::stitching_helper(), AllTriTest::test_helper_c0polyhedron(), MeshTetTest::testBcids(), BoundaryInfoTest::testBoundaryOnChildrenElementsRefineCoarsen(), SystemsTest::testBoundaryProjectCube(), BoundaryInfoTest::testBuildNodeListFromSideList(), BoundaryInfoTest::testBuildSideListFromNodeList(), and BoundaryInfoTest::testEdgeBoundaryConditions().

 {
   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 1530 of file boundary_info.C.

References boundary_ids().

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

◆ is_children_on_boundary_side()

bool libMesh::BoundaryInfo::is_children_on_boundary_side ( ) const

inline

Returns: Whether or not there may be child elements directly assigned boundary sides

Definition at line 935 of file boundary_info.h.

References _children_on_boundary.

Referenced by libMesh::MeshRefinement::_coarsen_elements(), libMesh::PetscDiffSolver::solve(), and BoundaryInfoTest::testBoundaryOnChildrenElementsRefineCoarsen().

936 { return _children_on_boundary; }

libMesh::BoundaryInfo::_children_on_boundary

bool _children_on_boundary

Definition: boundary_info.h:1007

◆ libmesh_assert_valid_multimaps()

void libMesh::BoundaryInfo::libmesh_assert_valid_multimaps ( ) const

private

Helper method for ensuring that our multimaps don't contain entries with duplicate keys and values.

Probably should have picked a different data structure there, and also not given users an accessor with raw access to it...

Definition at line 3579 of file boundary_info.C.

References _boundary_edge_id, _boundary_node_id, _boundary_shellface_id, _boundary_side_id, and libMesh::libmesh_assert().

Referenced by clear_stitched_boundary_side_ids(), renumber_edge_id(), renumber_id(), renumber_node_id(), renumber_shellface_id(), and renumber_side_id().

 {
 #ifndef NDEBUG
   auto verify_multimap = [](const auto & themap) {
     for (const auto & [key, val] : themap)
       {
         auto range = themap.equal_range(key);
 
         int count = 0;
         for (auto it = range.first; it != range.second; ++it)
           if (it->second == val)
             ++count;
 
         libmesh_assert(count == 1);
       }
   };
 
   verify_multimap(this->_boundary_node_id);
   verify_multimap(this->_boundary_edge_id);
   verify_multimap(this->_boundary_shellface_id);
   verify_multimap(this->_boundary_side_id);
 #else
   return;
 #endif
 }

◆ 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 2594 of file boundary_info.C.

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

Referenced by libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Modification::flatten(), libMesh::AbaqusIO::read(), libMesh::Nemesis_IO::read(), AllTriTest::test_helper_2D(), AllTriTest::test_helper_3D(), AllTriTest::test_helper_c0polyhedron(), AllTriTest::testAllTriC0Polygon(), AllTriTest::testAllTriC0PolygonOctagon(), 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 475 of file boundary_info.h.

References _boundary_ids.

Referenced by libMesh::MeshTools::Subdivision::all_subdivision(), MeshTetTest::testBcids(), BoundaryInfoTest::testBuildSideListFromNodeList(), MeshInputTest::testExodusIGASidesets(), MeshInputTest::testLowOrderEdgeBlocks(), BoundaryInfoTest::testMesh(), BoundaryInfoTest::testRenumber(), BoundaryInfoTest::testSelectiveRenumber(), and libMesh::FroIO::write().

475 { return _boundary_ids.size(); }

libMesh::BoundaryInfo::_boundary_ids

std::set< boundary_id_type > _boundary_ids

A collection of user-specified boundary ids for sides, edges, nodes, and shell faces.

Definition: boundary_info.h:1018

◆ 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 1360 of file boundary_info.C.

References _boundary_node_id, and distance().

 {
   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 1713 of file boundary_info.C.

References boundary_ids().

 {
   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 1428 of file boundary_info.C.

References edge_boundary_ids().

 {
   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 2615 of file boundary_info.C.

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

Referenced by libMesh::ExodusII_IO_Helper::initialize(), libMesh::Nemesis_IO::prepare_to_write_nodal_data(), BoundaryInfoTest::testEdgeBoundaryConditions(), WriteEdgesetData::testWriteImpl(), libMesh::Nemesis_IO::write(), libMesh::XdrIO::write(), and libMesh::ExodusII_IO::write().

 {
   // 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 2659 of file boundary_info.C.

References _boundary_node_id, _mesh, libMesh::ParallelObject::comm(), libMesh::MeshBase::is_serial(), libMesh::ParallelObject::processor_id(), and TIMPI::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 103 of file parallel_object.h.

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

   {
     processor_id_type returnval =
       cast_int<processor_id_type>(_communicator.size());
     libmesh_assert(returnval); // We never have an empty comm
     return returnval;
   }

◆ n_raw_boundary_ids()

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

Returns: The number of raw (excludes ancestors) boundary ids associated with the side side of element elem.

Definition at line 1722 of file boundary_info.C.

References raw_boundary_ids().

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

◆ 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 1496 of file boundary_info.C.

References shellface_boundary_ids().

 {
   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 2637 of file boundary_info.C.

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

Referenced by BoundaryInfoTest::testShellFaceConstraints(), and 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 3261 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(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::GmshIO::read_mesh(), MeshStitchTest::renameAndShift(), BoundaryInfoTest::testNameCopying(), BoundaryInfoTest::testSelectiveRenumber(), and WriteNodesetData::testWriteImpl().

 {
   return _ns_id_to_name[id];
 }

◆ operator!=()

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

inline

Definition at line 88 of file boundary_info.h.

   {
     return !(*this == other_boundary_info);
   }

◆ operator=()

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

Copy assignment operator.

Note: this will still reference the same MeshBase it was constructed with. Boundary data copied from other_boundary_info will refer to objects in this mesh which have the same DofObject::id() as the corresponding objects in the other mesh.

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 110 of file boundary_info.C.

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

 {
   // Overwrite any preexisting boundary info
   this->clear();
 
   // Copy node boundary info
   for (const auto & [node, bid] : other_boundary_info._boundary_node_id)
     _boundary_node_id.emplace(_mesh->node_ptr(node->id()), bid);
 
   // Copy edge boundary info
   for (const auto & [elem, id_pair] : other_boundary_info._boundary_edge_id)
     _boundary_edge_id.emplace(_mesh->elem_ptr(elem->id()), id_pair);
 
   // Copy shellface boundary info
   for (const auto & [elem, id_pair] : other_boundary_info._boundary_shellface_id)
     _boundary_shellface_id.emplace(_mesh->elem_ptr(elem->id()), id_pair);
 
   // Copy side boundary info
   for (const auto & [elem, id_pair] : other_boundary_info._boundary_side_id)
     _boundary_side_id.emplace(_mesh->elem_ptr(elem->id()), id_pair);
 
   _children_on_boundary = other_boundary_info._children_on_boundary;
 
   _boundary_ids = other_boundary_info._boundary_ids;
   _global_boundary_ids = other_boundary_info._global_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;
 
   _ss_id_to_name = other_boundary_info._ss_id_to_name;
   _ns_id_to_name = other_boundary_info._ns_id_to_name;
   _es_id_to_name = other_boundary_info._es_id_to_name;
 
   return *this;
 }

◆ operator==()

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

This tests for data equality via element ids.

Definition at line 158 of file boundary_info.C.

References _boundary_edge_id, _boundary_ids, _boundary_node_id, _boundary_shellface_id, _boundary_side_id, _children_on_boundary, _edge_boundary_ids, _es_id_to_name, _global_boundary_ids, _mesh, _node_boundary_ids, _ns_id_to_name, _shellface_boundary_ids, _side_boundary_ids, _ss_id_to_name, boundary_ids(), edge_boundary_ids(), has_boundary_id(), libMesh::DofObject::id(), libMesh::index_range(), libMesh::MeshBase::query_elem_ptr(), libMesh::MeshBase::query_node_ptr(), and shellface_boundary_ids().

 {
   for (const auto & [other_node, bid] : other_boundary_info._boundary_node_id)
     {
       const Node * node = this->_mesh->query_node_ptr(other_node->id());
       if (!node)
         return false;
       if (!this->has_boundary_id(node, bid))
         return false;
     }
   for (const auto & [node, bid] : this->_boundary_node_id)
     {
       const Node * other_node =
         other_boundary_info._mesh->query_node_ptr(node->id());
       if (!other_node)
         return false;
       if (!other_boundary_info.has_boundary_id(other_node, bid))
         return false;
     }
 
   auto compare_edges = [&](const Elem * elem,
                            const Elem * other_elem,
                            unsigned short int edge)
   {
     if (!elem)
       return false;
     if (!other_elem)
       return false;
 
     std::vector<boundary_id_type> our_edges, other_edges;
     this->edge_boundary_ids(elem, edge, our_edges);
     other_boundary_info.edge_boundary_ids(other_elem, edge, other_edges);
     if (our_edges.size() != other_edges.size())
       return false;
 
     std::sort(our_edges.begin(), our_edges.end());
     std::sort(other_edges.begin(), other_edges.end());
     for (auto i : index_range(our_edges))
       if (our_edges[i] != other_edges[i])
         return false;
     return true;
   };
 
   for (const auto & [other_elem, edge_id_pair] : other_boundary_info._boundary_edge_id)
     {
       const Elem * elem = this->_mesh->query_elem_ptr(other_elem->id());
       if (!compare_edges(elem, other_elem, edge_id_pair.first))
         return false;
     }
 
   for (const auto & [elem, edge_id_pair] : this->_boundary_edge_id)
     {
       const Elem * other_elem = other_boundary_info._mesh->query_elem_ptr(elem->id());
       if (!compare_edges(elem, other_elem, edge_id_pair.first))
         return false;
     }
 
   auto compare_sides = [&](const Elem * elem,
                            const Elem * other_elem,
                            unsigned short int side)
   {
     if (!elem)
       return false;
     if (!other_elem)
       return false;
 
     std::vector<boundary_id_type> our_sides, other_sides;
     this->boundary_ids(elem, side, our_sides);
     other_boundary_info.boundary_ids(other_elem, side, other_sides);
     if (our_sides.size() != other_sides.size())
       return false;
 
     std::sort(our_sides.begin(), our_sides.end());
     std::sort(other_sides.begin(), other_sides.end());
     for (auto i : index_range(our_sides))
       if (our_sides[i] != other_sides[i])
         return false;
     return true;
   };
 
   for (const auto & [other_elem, side_id_pair] : other_boundary_info._boundary_side_id)
     {
       const Elem * elem = this->_mesh->query_elem_ptr(other_elem->id());
       if (!compare_sides(elem, other_elem, side_id_pair.first))
         return false;
     }
 
   for (const auto & [elem, side_id_pair] : this->_boundary_side_id)
     {
       const Elem * other_elem = other_boundary_info._mesh->query_elem_ptr(elem->id());
       if (!compare_sides(elem, other_elem, side_id_pair.first))
         return false;
     }
 
   auto compare_shellfaces = [&](const Elem * elem,
                                 const Elem * other_elem,
                                 unsigned short int shellface)
   {
     if (!elem)
       return false;
     if (!other_elem)
       return false;
 
     std::vector<boundary_id_type> our_shellfaces, other_shellfaces;
     this->shellface_boundary_ids(elem, shellface, our_shellfaces);
     other_boundary_info.shellface_boundary_ids(other_elem, shellface, other_shellfaces);
     if (our_shellfaces.size() != other_shellfaces.size())
       return false;
 
     std::sort(our_shellfaces.begin(), our_shellfaces.end());
     std::sort(other_shellfaces.begin(), other_shellfaces.end());
     for (auto i : index_range(our_shellfaces))
       if (our_shellfaces[i] != other_shellfaces[i])
         return false;
     return true;
   };
 
   for (const auto & [other_elem, shellface_id_pair] : other_boundary_info._boundary_shellface_id)
     {
       const Elem * elem = this->_mesh->query_elem_ptr(other_elem->id());
       if (!compare_shellfaces(elem, other_elem, shellface_id_pair.first))
         return false;
     }
 
   for (const auto & [elem, shellface_id_pair] : this->_boundary_shellface_id)
     {
       const Elem * other_elem = other_boundary_info._mesh->query_elem_ptr(elem->id());
       if (!compare_shellfaces(elem, other_elem, shellface_id_pair.first))
         return false;
     }
 
   if (_children_on_boundary != other_boundary_info._children_on_boundary)
     return false;
 
   auto compare_sets = [](const auto & set1, const auto & set2)
   {
     if (set1.size() != set2.size())
       return false;
     for (boundary_id_type bid : set1)
       if (!set2.count(bid))
         return false;
 
     return true;
   };
 
   if (!compare_sets(_boundary_ids,
                     other_boundary_info._boundary_ids) ||
       !compare_sets(_global_boundary_ids,
                     other_boundary_info._global_boundary_ids) ||
       !compare_sets(_edge_boundary_ids,
                     other_boundary_info._edge_boundary_ids) ||
       !compare_sets(_node_boundary_ids,
                     other_boundary_info._node_boundary_ids) ||
       !compare_sets(_shellface_boundary_ids,
                     other_boundary_info._shellface_boundary_ids) ||
       !compare_sets(_side_boundary_ids,
                     other_boundary_info._side_boundary_ids))
     return false;
 
   auto compare_maps = [](const auto & map1, const auto & map2)
   {
     if (map1.size() != map2.size())
       return false;
     for (const auto & pair : map1)
       if (!map2.count(pair.first) ||
           map2.at(pair.first) != pair.second)
         return false;
 
     return true;
   };
 
   if (!compare_maps(_ss_id_to_name,
                     other_boundary_info._ss_id_to_name) ||
       !compare_maps(_ns_id_to_name,
                     other_boundary_info._ns_id_to_name) ||
       !compare_maps(_es_id_to_name,
                     other_boundary_info._es_id_to_name))
     return false;
 
   return true;
 }

◆ parallel_sync_node_ids()

void libMesh::BoundaryInfo::parallel_sync_node_ids ( )

Definition at line 2889 of file boundary_info.C.

References _boundary_node_id, _mesh, libMesh::as_range(), libMesh::ParallelObject::comm(), libMesh::index_range(), libMesh::MeshBase::node_ptr(), and libMesh::ParallelObject::processor_id().

 {
   // we need BCs for ghost nodes.
   std::unordered_map<processor_id_type, std::vector<dof_id_type>>
     node_ids_requested;
 
   // 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 != this->processor_id())
       node_ids_requested[pid].push_back(node->id());
   }
 
   typedef std::vector<boundary_id_type> datum_type;
 
   // gather the node ID and boundary_id_type for the ghost nodes
   auto node_id_gather_functor =
   [this]
   (processor_id_type,
     const std::vector<dof_id_type> & ids,
     std::vector<datum_type> & data)
     {
       data.resize(ids.size());
       for (auto i : index_range(ids))
       {
         Node * node = _mesh->node_ptr(ids[i]);
         for (const auto & pr : as_range(_boundary_node_id.equal_range(node)))
         data[i].push_back(pr.second);
       }
     };
 
     // update the _boundary_node_id on this processor
     auto node_id_action_functor =
       [this]
       (processor_id_type,
        const std::vector<dof_id_type> & ids,
        std::vector<datum_type> & data)
     {
         for (auto i : index_range(ids))
         {
           Node * node = _mesh->node_ptr(ids[i]);
           //clear boundary node
           _boundary_node_id.erase(node);
           // update boundary node
           for (const auto & pr : data[i])
             _boundary_node_id.insert(std::make_pair(node, pr));
         }
     };
 
 
     datum_type * datum_type_ex = nullptr;
     Parallel::pull_parallel_vector_data
       (this->comm(), node_ids_requested, node_id_gather_functor,
        node_id_action_functor, datum_type_ex);
 }

◆ parallel_sync_side_ids()

void libMesh::BoundaryInfo::parallel_sync_side_ids ( )

Synchronize the boundary element side and node across processors.

This function is needed when boundary info is changed by adding or removing sides on the fly. Note: if the side of a ghost element is changed, then you would need to do do parallel push (see e.g., timpi/parallel_sync.h) and then sync.

Definition at line 2833 of file boundary_info.C.

References _boundary_side_id, _mesh, libMesh::as_range(), libMesh::ParallelObject::comm(), libMesh::MeshBase::elem_ptr(), libMesh::index_range(), libMesh::ParallelObject::processor_id(), and side_id.

 {
   // we need BCs for ghost elements.
   std::unordered_map<processor_id_type, std::vector<dof_id_type>>
     elem_ids_requested;
 
   // Determine what elements we need to request
   for (const auto & elem : _mesh->element_ptr_range())
   {
     const processor_id_type pid = elem->processor_id();
     if (pid != this->processor_id())
       elem_ids_requested[pid].push_back(elem->id());
   }
 
   typedef std::vector<std::pair<unsigned short int, boundary_id_type>> datum_type;
 
   // gather the element ID, side, and boundary_id_type for the ghost elements
   auto elem_id_gather_functor =
     [this]
     (processor_id_type,
      const std::vector<dof_id_type> & ids,
      std::vector<datum_type> & data)
   {
     data.resize(ids.size());
     for (auto i : index_range(ids))
     {
       Elem * elem = _mesh->elem_ptr(ids[i]);
       for (const auto & pr : as_range(_boundary_side_id.equal_range(elem)))
         data[i].push_back(std::make_pair(pr.second.first, pr.second.second));
     }
   };
   // update the _boundary_side_id on this processor
   auto elem_id_action_functor =
     [this]
     (processor_id_type,
      const std::vector<dof_id_type> & ids,
      std::vector<datum_type> & data)
   {
       for (auto i : index_range(ids))
       {
         Elem * elem = _mesh->elem_ptr(ids[i]);
         //clear boundary sides for this element
         _boundary_side_id.erase(elem);
         // update boundary sides for it
         for (const auto & [side_id, bndry_id] : data[i])
           _boundary_side_id.insert(std::make_pair(elem, std::make_pair(side_id, bndry_id)));
       }
   };
 
 
   datum_type * datum_type_ex = nullptr;
   Parallel::pull_parallel_vector_data
     (this->comm(), elem_ids_requested, elem_id_gather_functor,
      elem_id_action_functor, datum_type_ex);
 }

◆ print_info()

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

Prints the boundary information data structure.

Definition at line 3092 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 & [node, bndry_id] : _boundary_node_id)
         out_stream << "  (" << node->id()
                    << ", "  << bndry_id
                    << ")"  << 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 & [elem, id_pair] : _boundary_edge_id)
         out_stream << "  (" << elem->id()
                    << ", "  << id_pair.first
                    << ", "  << id_pair.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 & [elem, id_pair] : _boundary_shellface_id)
         out_stream << "  (" << elem->id()
                    << ", "  << id_pair.first
                    << ", "  << id_pair.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 & [elem, id_pair] : _boundary_side_id)
         out_stream << "  (" << elem->id()
                    << ", "  << id_pair.first
                    << ", "  << id_pair.second
                    << ")"   << std::endl;
     }
 }

◆ print_summary()

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

Prints a summary of the boundary information.

Definition at line 3155 of file boundary_info.C.

References _boundary_edge_id, _boundary_node_id, _boundary_shellface_id, and _boundary_side_id.

Referenced by main().

 {
   // 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 & [bndry_id, cnt] : ID_counts)
         out_stream << "  (" << bndry_id
                    << ", "  << cnt
                    << ")"  << 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 & [bndry_id, cnt] : ID_counts)
         out_stream << "  (" << bndry_id
                    << ", "  << cnt
                    << ")"  << 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 & [bndry_id, cnt] : ID_counts)
         out_stream << "  (" << bndry_id
                    << ", "  << cnt
                    << ")"  << 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 & [bndry_id, cnt] : ID_counts)
         out_stream << "  (" << bndry_id
                    << ", "  << cnt
                    << ")"  << 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 114 of file parallel_object.h.

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

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

TIMPI::Communicator::rank

processor_id_type rank() const

libMesh::ParallelObject::_communicator

const Parallel::Communicator & _communicator

Definition: parallel_object.h:120

◆ raw_boundary_ids()

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.

Definition at line 1732 of file boundary_info.C.

References _boundary_side_id, _children_on_boundary, libMesh::as_range(), libMesh::libmesh_assert(), libMesh::Elem::n_sides(), and libMesh::Elem::parent().

Referenced by copy_boundary_ids(), n_raw_boundary_ids(), and remove_side().

 {
   libmesh_assert(elem);
 
   // Only query BCs for sides that exist.
   libmesh_assert_less (side, elem->n_sides());
 
   // Clear out any previous contents
   vec_to_fill.clear();
 
   // Only level-0 elements store BCs.
   if (elem->parent() && !_children_on_boundary)
     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()

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.

Definition at line 1438 of file boundary_info.C.

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

Referenced by copy_boundary_ids().

 {
   libmesh_assert(elem);
 
   // Only query BCs for edges that exist.
   libmesh_assert_less (edge, elem->n_edges());
 
   // 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 1506 of file boundary_info.C.

References _boundary_shellface_id, libMesh::as_range(), libMesh::libmesh_assert(), 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 in general 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 363 of file boundary_info.C.

References _boundary_edge_id, _boundary_ids, _boundary_node_id, _boundary_shellface_id, _boundary_side_id, libMesh::ParallelObject::_communicator, _edge_boundary_ids, _es_id_to_name, _mesh, _node_boundary_ids, _ns_id_to_name, _shellface_boundary_ids, _side_boundary_ids, _ss_id_to_name, libMesh::MeshBase::is_serial(), libMesh::libmesh_assert(), TIMPI::Communicator::set_union(), and synchronize_global_id_set().

Referenced by libMesh::UnstructuredMesh::all_first_order(), clear_stitched_boundary_side_ids(), libMesh::MeshBase::complete_preparation(), libMesh::MeshTetInterface::delete_2D_hull_elements(), libMesh::DistributedMesh::delete_remote_elements(), main(), and libMesh::TetGenMeshInterface::pointset_convexhull().

 {
   const auto old_ss_id_to_name = _ss_id_to_name;
   const auto old_ns_id_to_name = _ns_id_to_name;
   const auto old_es_id_to_name = _es_id_to_name;
 
   // Clear the old caches
   _boundary_ids.clear();
   _side_boundary_ids.clear();
   _node_boundary_ids.clear();
   _edge_boundary_ids.clear();
   _shellface_boundary_ids.clear();
   _ss_id_to_name.clear();
   _ns_id_to_name.clear();
   _es_id_to_name.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);
       if (const auto it = old_ns_id_to_name.find(id);
           it != old_ns_id_to_name.end())
         _ns_id_to_name.emplace(id, it->second);
     }
 
   for (const auto & pr : _boundary_edge_id)
     {
       const boundary_id_type id = pr.second.second;
       _boundary_ids.insert(id);
       _edge_boundary_ids.insert(id);
       if (const auto it = old_es_id_to_name.find(id);
           it != old_es_id_to_name.end())
         _es_id_to_name.emplace(id, it->second);
     }
 
   for (const auto & pr : _boundary_side_id)
     {
       const boundary_id_type id = pr.second.second;
       _boundary_ids.insert(id);
       _side_boundary_ids.insert(id);
       if (const auto it = old_ss_id_to_name.find(id);
           it != old_ss_id_to_name.end())
         _ss_id_to_name.emplace(id, it->second);
     }
 
   for (const auto & pr : _boundary_shellface_id)
     {
       const boundary_id_type id = pr.second.second;
       _boundary_ids.insert(id);
       _shellface_boundary_ids.insert(id);
     }
 
   // Handle global data
   libmesh_assert(_mesh);
   if (!_mesh->is_serial())
     {
       _communicator.set_union(_ss_id_to_name);
       _communicator.set_union(_ns_id_to_name);
       _communicator.set_union(_es_id_to_name);
     }
 
   this->synchronize_global_id_set();
 }

◆ remove() [1/2]

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

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

Definition at line 1786 of file boundary_info.C.

References _boundary_node_id, and libMesh::libmesh_assert().

Referenced by libMesh::MeshRefinement::_coarsen_elements(), libMesh::MeshTools::Subdivision::all_subdivision(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_cube(), libMesh::ReplicatedMesh::delete_elem(), libMesh::DistributedMesh::delete_elem(), libMesh::ReplicatedMesh::delete_node(), libMesh::DistributedMesh::delete_node(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::SimplexRefiner::refine_via_edges(), 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 1809 of file boundary_info.C.

References _boundary_edge_id, _boundary_shellface_id, _boundary_side_id, and libMesh::libmesh_assert().

 {
   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 1821 of file boundary_info.C.

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

Referenced by renumber_edge_id(), renumber_id(), and libMesh::Elem::swap2boundaryedges().

 {
   libmesh_assert(elem);
 
   // Only touch BCs for edges that exist.
   libmesh_assert_less (edge, elem->n_edges());
 
   // Only level 0 elements are stored in BoundaryInfo.
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Erase (elem, edge, *) entries from map.
   erase_if(_boundary_edge_id, elem,
            [edge](decltype(_boundary_edge_id)::mapped_type & pr)
            {return pr.first == edge;});
 }

◆ 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 1840 of file boundary_info.C.

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

 {
   libmesh_assert(elem);
 
   // Only touch BCs for edges that exist.
   libmesh_assert_less (edge, elem->n_edges());
 
   // Only level 0 elements are stored in BoundaryInfo.
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Erase (elem, edge, id) entries from map.
   erase_if(_boundary_edge_id, elem,
            [edge, id](decltype(_boundary_edge_id)::mapped_type & pr)
            {return pr.first == edge && pr.second == id;});
 }

◆ remove_edge_id()

void libMesh::BoundaryInfo::remove_edge_id	(	boundary_id_type	id,
		bool	global = `false`
	)

Removes all edges with boundary id id from the BoundaryInfo object, removes it from the set of edge boundary ids, and removes it from the set of boundary ids if no other boundary type uses it.

Set the global parameter to true if this is being called for all processes in the object's communicator, in which case we will remove the id from the global boundary ID container

Definition at line 1990 of file boundary_info.C.

References _boundary_edge_id, _boundary_ids, _edge_boundary_ids, _es_id_to_name, _global_boundary_ids, _node_boundary_ids, _shellface_boundary_ids, _side_boundary_ids, libMesh::ParallelObject::comm(), and TIMPI::Communicator::max().

Referenced by remove_id().

 {
   // Erase id from ids containers
   _edge_boundary_ids.erase(id);
 
   if (!_side_boundary_ids.count(id) &&
       !_shellface_boundary_ids.count(id) &&
       !_node_boundary_ids.count(id))
     _boundary_ids.erase(id);
 
   _es_id_to_name.erase(id);
   if (global)
     {
       bool someone_has_it = _boundary_ids.count(id);
       this->comm().max(someone_has_it);
       if (!someone_has_it)
         _global_boundary_ids.erase(id);
     }
 
   // Erase (*, *, id) entries from map.
   erase_if(_boundary_edge_id,
            [id](decltype(_boundary_edge_id)::mapped_type & pr)
            {return pr.second == id;});
 }

◆ remove_id()

void libMesh::BoundaryInfo::remove_id	(	boundary_id_type	id,
		bool	global = `false`
	)

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.

Set the global parameter to true if this is being called for all processes in the object's communicator, in which case we will remove the id from the global boundary ID container

Definition at line 1948 of file boundary_info.C.

References _global_boundary_ids, remove_edge_id(), remove_node_id(), remove_shellface_id(), and remove_side_id().

Referenced by BoundaryInfoTest::testMesh(), and BoundaryInfoTest::testRenumber().

 {
   // Pass global==false to the sub-methods here, so we can avoid
   // unnecessary communications
   this->remove_side_id(id, false);
   this->remove_edge_id(id, false);
   this->remove_shellface_id(id, false);
   this->remove_node_id(id, false);
 
   if (global)
     _global_boundary_ids.erase(id);
 }

◆ remove_node()

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

Removes boundary id id from node node, if it exists.

Definition at line 1796 of file boundary_info.C.

References _boundary_node_id, and libMesh::libmesh_assert().

Referenced by clear_stitched_boundary_side_ids(), renumber_id(), and renumber_node_id().

 {
   libmesh_assert(node);
 
   // Erase (node, id) entry from map.
   erase_if(_boundary_node_id, node,
            [id](decltype(_boundary_node_id)::mapped_type & val)
            {return val == id;});
 }

◆ remove_node_id()

void libMesh::BoundaryInfo::remove_node_id	(	boundary_id_type	id,
		bool	global = `false`
	)

Removes all nodes with boundary id id from the BoundaryInfo object, removes it from the set of node boundary ids, and removes it from the set of boundary ids if no other boundary type uses it.

Set the global parameter to true if this is being called for all processes in the object's communicator, in which case we will remove the id from the global boundary ID container

Definition at line 2043 of file boundary_info.C.

References _boundary_ids, _boundary_node_id, _edge_boundary_ids, _global_boundary_ids, _node_boundary_ids, _ns_id_to_name, _shellface_boundary_ids, _side_boundary_ids, libMesh::ParallelObject::comm(), and TIMPI::Communicator::max().

Referenced by remove_id(), and BoundaryInfoTest::testBuildNodeListFromSideList().

 {
   // Erase id from ids containers
   _node_boundary_ids.erase(id);
 
   if (!_side_boundary_ids.count(id) &&
       !_edge_boundary_ids.count(id) &&
       !_shellface_boundary_ids.count(id))
     _boundary_ids.erase(id);
 
   _ns_id_to_name.erase(id);
   if (global)
     {
       bool someone_has_it = _boundary_ids.count(id);
       this->comm().max(someone_has_it);
       if (!someone_has_it)
         _global_boundary_ids.erase(id);
     }
 
   // Erase (*, id) entries from map.
   erase_if(_boundary_node_id,
            [id](decltype(_boundary_node_id)::mapped_type & val)
            {return val == id;});
 }

◆ 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 1859 of file boundary_info.C.

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

Referenced by renumber_id(), and renumber_shellface_id().

 {
   libmesh_assert(elem);
 
   // Only level 0 elements are stored in BoundaryInfo.
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Shells only have 2 faces
   libmesh_assert_less(shellface, 2);
 
   // Erase (elem, shellface, *) entries from map.
   erase_if(_boundary_shellface_id, elem,
            [shellface](decltype(_boundary_shellface_id)::mapped_type & pr)
            {return pr.first == shellface;});
 }

◆ 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 1878 of file boundary_info.C.

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

 {
   libmesh_assert(elem);
 
   // Only level 0 elements are stored in BoundaryInfo.
   libmesh_assert_equal_to (elem->level(), 0);
 
   // Shells only have 2 faces
   libmesh_assert_less(shellface, 2);
 
   // Erase (elem, shellface, id) entries from map.
   erase_if(_boundary_shellface_id, elem,
            [shellface, id](decltype(_boundary_shellface_id)::mapped_type & pr)
            {return pr.first == shellface && pr.second == id;});
 }

◆ remove_shellface_id()

void libMesh::BoundaryInfo::remove_shellface_id	(	boundary_id_type	id,
		bool	global = `false`
	)

Removes all shellfaces with boundary id id from the BoundaryInfo object, removes it from the set of shellface boundary ids, and removes it from the set of boundary ids if no other boundary type uses it.

Set the global parameter to true if this is being called for all processes in the object's communicator, in which case we will remove the id from the global boundary ID container

Definition at line 2017 of file boundary_info.C.

References _boundary_ids, _boundary_shellface_id, _edge_boundary_ids, _global_boundary_ids, _node_boundary_ids, _shellface_boundary_ids, _side_boundary_ids, libMesh::ParallelObject::comm(), and TIMPI::Communicator::max().

Referenced by remove_id().

 {
   // Erase id from ids containers
   _shellface_boundary_ids.erase(id);
 
   if (!_side_boundary_ids.count(id) &&
       !_edge_boundary_ids.count(id) &&
       !_node_boundary_ids.count(id))
     _boundary_ids.erase(id);
 
   if (global)
     {
       bool someone_has_it = _boundary_ids.count(id);
       this->comm().max(someone_has_it);
       if (!someone_has_it)
         _global_boundary_ids.erase(id);
     }
 
   // Erase (*, *, id) entries from map.
   erase_if(_boundary_shellface_id,
            [id](decltype(_boundary_shellface_id)::mapped_type & pr)
            {return pr.second == id;});
 }

◆ 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 1896 of file boundary_info.C.

References _boundary_side_id, libMesh::libmesh_assert(), and libMesh::Elem::n_sides().

Referenced by main(), renumber_id(), renumber_side_id(), libMesh::Elem::swap2boundarysides(), BoundaryInfoTest::testBoundaryOnChildrenElementsRefineCoarsen(), and BoundaryInfoTest::testBoundaryOnChildrenErrors().

 {
   libmesh_assert(elem);
 
   // Only touch BCs for sides that exist.
   libmesh_assert_less (side, elem->n_sides());
 
   // Erase (elem, side, *) entries from map.
   erase_if(_boundary_side_id, elem,
            [side](decltype(_boundary_side_id)::mapped_type & pr)
            {return pr.first == side;});
 }

◆ 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 1912 of file boundary_info.C.

References _boundary_side_id, boundary_ids(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::Elem::n_sides(), and raw_boundary_ids().

 {
   libmesh_assert(elem);
 
   // Only touch BCs for sides that exist.
   libmesh_assert_less (side, elem->n_sides());
 
 #ifdef LIBMESH_ENABLE_AMR
   // Here we have to stop and check if somebody tries to remove an ancestor's boundary ID
   // through a child
   if (elem->level())
   {
     std::vector<boundary_id_type> bd_ids;
     this->boundary_ids(elem,side,bd_ids);
     if(std::find(bd_ids.begin(), bd_ids.end(), id) != bd_ids.end())
     {
       std::vector<boundary_id_type> raw_bd_ids;
       this->raw_boundary_ids(elem, side, raw_bd_ids);
       if(std::find(raw_bd_ids.begin(), raw_bd_ids.end(), id) == raw_bd_ids.end())
         libmesh_not_implemented_msg("We cannot delete boundary ID "
                                     + std::to_string(id) +
                                     " using a child because it is inherited from an ancestor.");
     }
   }
 #endif
 
   // Erase (elem, side, id) entries from map.
   erase_if(_boundary_side_id, elem,
            [side, id](decltype(_boundary_side_id)::mapped_type & pr)
            {return pr.first == side && pr.second == id;});
 }

◆ remove_side_id()

void libMesh::BoundaryInfo::remove_side_id	(	boundary_id_type	id,
		bool	global = `false`
	)

Removes all sides with boundary id id from the BoundaryInfo object, removes it from the set of side boundary ids, and removes it from the set of boundary ids if no other boundary type uses it.

Set the global parameter to true if this is being called for all processes in the object's communicator, in which case we will remove the id from the global boundary ID container

Definition at line 1963 of file boundary_info.C.

References _boundary_ids, _boundary_side_id, _edge_boundary_ids, _global_boundary_ids, _node_boundary_ids, _shellface_boundary_ids, _side_boundary_ids, _ss_id_to_name, libMesh::ParallelObject::comm(), and TIMPI::Communicator::max().

Referenced by remove_id(), and BoundaryInfoTest::testBuildSideListFromNodeList().

 {
   // Erase id from ids containers
   _side_boundary_ids.erase(id);
 
   if (!_edge_boundary_ids.count(id) &&
       !_shellface_boundary_ids.count(id) &&
       !_node_boundary_ids.count(id))
     _boundary_ids.erase(id);
 
   _ss_id_to_name.erase(id);
   if (global)
     {
       bool someone_has_it = _boundary_ids.count(id);
       this->comm().max(someone_has_it);
       if (!someone_has_it)
         _global_boundary_ids.erase(id);
     }
 
   // Erase (*, *, id) entries from map.
   erase_if(_boundary_side_id,
            [id](decltype(_boundary_side_id)::mapped_type & pr)
            {return pr.second == id;});
 }

◆ renumber_edge_id()

void libMesh::BoundaryInfo::renumber_edge_id	(	boundary_id_type	old_id,
		boundary_id_type	new_id
	)

Changes all edges with boundary id old_id to instead be labeled by boundary id new_id.

Definition at line 2197 of file boundary_info.C.

References _boundary_edge_id, _boundary_ids, _edge_boundary_ids, _es_id_to_name, _node_boundary_ids, _shellface_boundary_ids, _side_boundary_ids, libmesh_assert_valid_multimaps(), and remove_edge().

Referenced by BoundaryInfoTest::testSelectiveRenumber().

 {
   // If the IDs are the same, this is a no-op.
   if (old_id == new_id)
     return;
 
   bool found_edge = false;
   for (auto & p : _boundary_edge_id)
     if (p.second.second == old_id)
       {
         // If we already have this id on this edge, we don't want to
         // create a duplicate in our multimap
         this->remove_edge(p.first, p.second.first, new_id);
         p.second.second = new_id;
         found_edge = true;
       }
   _edge_boundary_ids.erase(old_id);
 
   if (found_edge)
     {
       _edge_boundary_ids.insert(new_id);
 
       if (!_shellface_boundary_ids.count(old_id) &&
           !_side_boundary_ids.count(old_id) &&
           !_node_boundary_ids.count(old_id))
         {
           _boundary_ids.erase(old_id);
         }
       _boundary_ids.insert(new_id);
     }
 
   renumber_name(_es_id_to_name, old_id, new_id);
 
   this->libmesh_assert_valid_multimaps();
 }

◆ renumber_id()

void libMesh::BoundaryInfo::renumber_id	(	boundary_id_type	old_id,
		boundary_id_type	new_id
	)

Changes all entities (nodes, sides, edges, shellfaces) with boundary id old_id to instead be labeled by boundary id new_id.

Definition at line 2070 of file boundary_info.C.

References _boundary_edge_id, _boundary_ids, _boundary_node_id, _boundary_shellface_id, _boundary_side_id, _edge_boundary_ids, _es_id_to_name, _node_boundary_ids, _ns_id_to_name, _shellface_boundary_ids, _side_boundary_ids, _ss_id_to_name, libmesh_assert_valid_multimaps(), remove_edge(), remove_node(), remove_shellface(), and remove_side().

Referenced by libMesh::MeshTools::Modification::change_boundary_id(), and BoundaryInfoTest::testRenumber().

 {
   if (old_id == new_id)
     {
       // If the IDs are the same, this is a no-op.
       return;
     }
 
   bool found_node = false;
   for (auto & p : _boundary_node_id)
     if (p.second == old_id)
       {
         // If we already have this id on this node, we don't want to
         // create a duplicate in our multimap
         this->remove_node(p.first, new_id);
         p.second = new_id;
         found_node = true;
       }
   if (found_node)
     {
       _node_boundary_ids.erase(old_id);
       _node_boundary_ids.insert(new_id);
     }
 
   bool found_edge = false;
   for (auto & p : _boundary_edge_id)
     if (p.second.second == old_id)
       {
         // If we already have this id on this edge, we don't want to
         // create a duplicate in our multimap
         this->remove_edge(p.first, p.second.first, new_id);
         p.second.second = new_id;
         found_edge = true;
       }
   if (found_edge)
     {
       _edge_boundary_ids.erase(old_id);
       _edge_boundary_ids.insert(new_id);
     }
 
   bool found_shellface = false;
   for (auto & p : _boundary_shellface_id)
     if (p.second.second == old_id)
       {
         // If we already have this id on this shellface, we don't want
         // to create a duplicate in our multimap
         this->remove_shellface(p.first, p.second.first, new_id);
         p.second.second = new_id;
         found_shellface = true;
       }
   if (found_shellface)
     {
       _shellface_boundary_ids.erase(old_id);
       _shellface_boundary_ids.insert(new_id);
     }
 
   bool found_side = false;
   for (auto & p : _boundary_side_id)
     if (p.second.second == old_id)
       {
         // If we already have this id on this side, we don't want to
         // create a duplicate in our multimap
         this->remove_side(p.first, p.second.first, new_id);
         p.second.second = new_id;
         found_side = true;
       }
   if (found_side)
     {
       _side_boundary_ids.erase(old_id);
       _side_boundary_ids.insert(new_id);
     }
 
   if (found_node || found_edge || found_shellface || found_side)
     {
       _boundary_ids.erase(old_id);
       _boundary_ids.insert(new_id);
     }
 
   renumber_name(_ss_id_to_name, old_id, new_id);
   renumber_name(_ns_id_to_name, old_id, new_id);
   renumber_name(_es_id_to_name, old_id, new_id);
 
   this->libmesh_assert_valid_multimaps();
 }

◆ renumber_node_id()

void libMesh::BoundaryInfo::renumber_node_id	(	boundary_id_type	old_id,
		boundary_id_type	new_id
	)

Changes all nodes with boundary id old_id to instead be labeled by boundary id new_id.

Definition at line 2273 of file boundary_info.C.

References _boundary_ids, _boundary_node_id, _edge_boundary_ids, _node_boundary_ids, _ns_id_to_name, _shellface_boundary_ids, _side_boundary_ids, libmesh_assert_valid_multimaps(), and remove_node().

Referenced by BoundaryInfoTest::testSelectiveRenumber().

 {
   // If the IDs are the same, this is a no-op.
   if (old_id == new_id)
     return;
 
   bool found_node = false;
   for (auto & p : _boundary_node_id)
     if (p.second == old_id)
       {
         // If we already have this id on this node, we don't want to
         // create a duplicate in our multimap
         this->remove_node(p.first, new_id);
         p.second = new_id;
         found_node = true;
       }
   _node_boundary_ids.erase(old_id);
 
   if (found_node)
     {
       _node_boundary_ids.insert(new_id);
 
       if (!_shellface_boundary_ids.count(old_id) &&
           !_side_boundary_ids.count(old_id) &&
           !_edge_boundary_ids.count(old_id))
         {
           _boundary_ids.erase(old_id);
         }
       _boundary_ids.insert(new_id);
     }
 
   renumber_name(_ns_id_to_name, old_id, new_id);
 
   this->libmesh_assert_valid_multimaps();
 }

◆ renumber_shellface_id()

void libMesh::BoundaryInfo::renumber_shellface_id	(	boundary_id_type	old_id,
		boundary_id_type	new_id
	)

Changes all shellfaces with boundary id old_id to instead be labeled by boundary id new_id.

Definition at line 2236 of file boundary_info.C.

References _boundary_ids, _boundary_shellface_id, _edge_boundary_ids, _node_boundary_ids, _shellface_boundary_ids, _side_boundary_ids, libmesh_assert_valid_multimaps(), and remove_shellface().

 {
   // If the IDs are the same, this is a no-op.
   if (old_id == new_id)
     return;
 
   bool found_shellface = false;
   for (auto & p : _boundary_shellface_id)
     if (p.second.second == old_id)
       {
         // If we already have this id on this shellface, we don't want
         // to create a duplicate in our multimap
         this->remove_shellface(p.first, p.second.first, new_id);
         p.second.second = new_id;
         found_shellface = true;
       }
   _shellface_boundary_ids.erase(old_id);
 
   if (found_shellface)
     {
       _shellface_boundary_ids.insert(new_id);
 
       if (!_edge_boundary_ids.count(old_id) &&
           !_side_boundary_ids.count(old_id) &&
           !_node_boundary_ids.count(old_id))
         {
           _boundary_ids.erase(old_id);
         }
       _boundary_ids.insert(new_id);
     }
 
   this->libmesh_assert_valid_multimaps();
 }

◆ renumber_side_id()

void libMesh::BoundaryInfo::renumber_side_id	(	boundary_id_type	old_id,
		boundary_id_type	new_id
	)

Changes all sides with boundary id old_id to instead be labeled by boundary id new_id.

Definition at line 2158 of file boundary_info.C.

References _boundary_ids, _boundary_side_id, _edge_boundary_ids, _node_boundary_ids, _shellface_boundary_ids, _side_boundary_ids, _ss_id_to_name, libmesh_assert_valid_multimaps(), and remove_side().

Referenced by BoundaryInfoTest::testSelectiveRenumber().

 {
   // If the IDs are the same, this is a no-op.
   if (old_id == new_id)
     return;
 
   bool found_side = false;
   for (auto & p : _boundary_side_id)
     if (p.second.second == old_id)
       {
         // If we already have this id on this side, we don't want to
         // create a duplicate in our multimap
         this->remove_side(p.first, p.second.first, new_id);
         p.second.second = new_id;
         found_side = true;
       }
   _side_boundary_ids.erase(old_id);
 
   if (found_side)
     {
       _side_boundary_ids.insert(new_id);
 
       if (!_shellface_boundary_ids.count(old_id) &&
           !_edge_boundary_ids.count(old_id) &&
           !_node_boundary_ids.count(old_id))
         {
           _boundary_ids.erase(old_id);
         }
       _boundary_ids.insert(new_id);
     }
 
   renumber_name(_ss_id_to_name, old_id, new_id);
 
   this->libmesh_assert_valid_multimaps();
 }

◆ set_edgeset_name_map()

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

inline

Returns: Writable/const reference to the edgeset name map.

Definition at line 903 of file boundary_info.h.

References _es_id_to_name.

Referenced by libMesh::MeshTools::Generation::build_extrusion(), and libMesh::UnstructuredMesh::stitching_helper().

904 { return _es_id_to_name; }

libMesh::BoundaryInfo::_es_id_to_name

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

This structure maintains the mapping of named edge sets for file formats (Exodus, Gmsh) that support ...

Definition: boundary_info.h:1102

◆ set_mesh()

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

inlineprotected

Definition at line 70 of file boundary_info.h.

References _mesh.

70 { _mesh = &m; }

libMesh::BoundaryInfo::_mesh

MeshBase * _mesh

A pointer to the Mesh this boundary info pertains to.

Definition: boundary_info.h:969

◆ 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 895 of file boundary_info.h.

References _ns_id_to_name.

Referenced by libMesh::MeshTools::Generation::build_extrusion(), libMesh::CheckpointIO::read_header(), and libMesh::UnstructuredMesh::stitching_helper().

896 { return _ns_id_to_name; }

libMesh::BoundaryInfo::_ns_id_to_name

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

This structure maintains the mapping of named node sets for file formats (Exodus, Gmsh) that support ...

Definition: boundary_info.h:1093

◆ 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 887 of file boundary_info.h.

References _ss_id_to_name.

Referenced by libMesh::MeshTools::Generation::build_extrusion(), libMesh::CheckpointIO::read_header(), and libMesh::UnstructuredMesh::stitching_helper().

888 { return _ss_id_to_name; }

libMesh::BoundaryInfo::_ss_id_to_name

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

This structure maintains the mapping of named side sets for file formats (Exodus, Gmsh) that support ...

Definition: boundary_info.h:1084

◆ 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 1462 of file boundary_info.C.

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

Referenced by assemble_shell(), n_shellface_boundary_ids(), operator==(), 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_boundary_ids()

void libMesh::BoundaryInfo::side_boundary_ids	(	const Elem *const	elem,
		std::vector< std::vector< boundary_id_type >> &	vec_to_fill
	)		const

Returns: The list of boundary ids associated with any of the sides of element elem. Indexed by sides.

Definition at line 1540 of file boundary_info.C.

References _boundary_side_id, _children_on_boundary, libMesh::as_range(), libMesh::invalid_uint, libMesh::Elem::is_child_on_side(), libMesh::Elem::level(), libMesh::libmesh_assert(), libMesh::make_range(), libMesh::Elem::n_sides(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::parent(), libMesh::Elem::top_parent(), and libMesh::Elem::which_child_am_i().

Referenced by BoundaryInfoTest::testBoundaryIDs(), and BoundaryInfoTest::testBoundaryOnChildrenBoundaryIDs().

 {
   libmesh_assert(elem);
 
   // Clear out any previous contents
   vec_to_fill.clear();
   auto num_sides = elem->n_sides();
 
   // No sides, no boundary ids
   if (!num_sides)
     return;
 
   // We are going to gather boundary ids for each side
   vec_to_fill.resize(num_sides);
   // In most cases only level-0 elements store BCs.
   // In certain applications (such as time-dependent domains), however, children
   // need to store BCs too. This case is covered with the _children_on_boundary
   // flag.
   const Elem * searched_elem = elem;
 
 #ifdef LIBMESH_ENABLE_AMR
   if (elem->level() != 0)
   {
     // If we have children on the boundaries, we need to search for boundary IDs on the
     // child and its ancestors too if they share the side.
     if (_children_on_boundary)
     {
       // Loop over ancestors to check if they have boundary ids on the same side
       std::vector<bool> search_on_side(elem->n_sides(), true);
       bool keep_searching = true;
       while (searched_elem && keep_searching)
       {
         for (const auto & pr : as_range(_boundary_side_id.equal_range(searched_elem)))
         {
           for (const auto side : make_range(elem->n_sides()))
             // Here we need to check if the boundary id already exists
             if (search_on_side[side] && pr.second.first == side &&
                 std::find(vec_to_fill[side].begin(), vec_to_fill[side].end(), pr.second.second) ==
                           vec_to_fill[side].end())
               vec_to_fill[side].push_back(pr.second.second);
         }
 
         const Elem * parent = searched_elem->parent();
         const auto child_index = parent ? parent->which_child_am_i(searched_elem) : libMesh::invalid_uint;
         for (const auto side : make_range(elem->n_sides()))
           // If the parent doesn't exist or if the child is not on the correct side of the
           // parent we are done checking the ancestors
           if (search_on_side[side] &&
                 (!parent || parent->is_child_on_side(child_index, side) == false))
             search_on_side[side] = false;
 
         searched_elem = parent;
         // if found what we needed on all sides, exit
         keep_searching = *std::max_element(search_on_side.begin(), search_on_side.end());
       }
 
       return;
     }
 
     // Children not on boundaries case.
     // It could be that a children is interior to the parent (search_on_side = false will handle that)
     // However, since no children on boundaries, we know that it's either the top parent or nothing
     std::vector<bool> search_on_side(elem->n_sides(), true);
     for (const auto side : make_range(elem->n_sides()))
     {
       // Reset the search level for each side
       const Elem * searched_elem_for_side = elem;
 
       // If we don't have children on boundaries and we are on an external boundary,
       // we will just use the top parent. search_on_side[side] = true works
       if (elem->neighbor_ptr(side) == nullptr)
         continue;
       // Otherwise we loop over the ancestors and check if they have a different BC for us
       else
         while (searched_elem_for_side->parent() != nullptr)
         {
           const Elem * parent = searched_elem_for_side->parent();
           if (search_on_side[side] && parent->is_child_on_side(parent->which_child_am_i(searched_elem_for_side), side) == false)
             search_on_side[side] = false;
           searched_elem_for_side = parent;
         }
     }
     // Now search on the top parent, only if we need to (element is not deep inside the top parent)
     if (*std::max_element(search_on_side.begin(), search_on_side.end()))
       for (const auto & pr : as_range(_boundary_side_id.equal_range(elem->top_parent())))
         if (search_on_side[pr.second.first])
           vec_to_fill[pr.second.first].push_back(pr.second.second);
     return;
   }
 #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)))
     vec_to_fill[pr.second.first].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 2312 of file boundary_info.C.

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

Referenced by assemble_temperature_jump(), BoundaryInfoTest::testBoundaryOnChildrenBoundarySides(), and BoundaryInfoTest::testInternalBoundary().

 {
   const Elem * searched_elem = elem;
 
   // If we don't have a time-dependent domain, we can just go ahead and use the top parent
   // (since only those contain boundary conditions). Otherwise, we keep the element
   if (elem->level() != 0 && !_children_on_boundary)
       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;
 
         // Here we branch out. If we don't allow time-dependent boundary domains,
         // we need to check if our parents are consistent.
         if (!_children_on_boundary)
         {
 #ifdef LIBMESH_ENABLE_AMR
           // If we're on this external boundary then we share this
           // external boundary id
           if (elem->neighbor_ptr(side) == nullptr)
             return side;
 
           // Internal boundary case
           const Elem * p = elem;
 
           // If we're on an internal boundary then we need to be sure
           // it's the same internal boundary as our top_parent
           while (p != nullptr)
           {
             const Elem * parent = p->parent();
             if (parent && !parent->is_child_on_side(parent->which_child_am_i(p), side))
               break;
             p = parent;
           }
 
           // We're on that side of our top_parent; return it
           if (!p)
             return side;
 #else
           // do not forget to return the internal boundary when AMR is disabled
           return side;
 #endif
         }
         // Otherwise we need to check if the child's ancestors have something on
         // the side of the child
         else
           return side;
       }
   }
 
 #ifdef LIBMESH_ENABLE_AMR
   // We might have instances (especially with moving boundary domains) when we
   // query the paren't boundary ID on a child. We only do this till we find the
   // the first side, for multiple sides see above.
   if (_children_on_boundary && elem->level() != 0)
   {
     for (auto side : make_range(elem->n_sides()))
     {
       const Elem * p = elem;
       while (p->parent() != nullptr)
       {
         const Elem * parent = p->parent();
 
         // First we make sure the parent shares this side
         if (parent->is_child_on_side(parent->which_child_am_i(p), side))
         {
           // parent may have multiple boundary ids
           for (const auto & pr : as_range(_boundary_side_id.equal_range(parent)))
             // if this is true we found the requested boundary_id
             // of the element and want to return the side
             if (pr.second.first == side && pr.second.second == boundary_id_in)
               return side;
 
           p = parent;
         }
         // If the parent is not on the same side, other ancestors won't be on the same side either
         else
           break;
       }
     }
   }
 #endif
 
   // 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;
 }

◆ sides_with_boundary_id()

std::vector< unsigned int > libMesh::BoundaryInfo::sides_with_boundary_id	(	const Elem *const	elem,
		const boundary_id_type	boundary_id
	)		const

Returns: All sides of element elem whose associated boundary id is boundary_id

Definition at line 2409 of file boundary_info.C.

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

Referenced by BoundaryInfoTest::testBoundaryOnChildrenBoundarySides().

 {
   std::vector<unsigned int> returnval;
 
   const Elem * searched_elem = elem;
   if (elem->level() != 0 && !_children_on_boundary)
     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;
 
         // Here we branch out. If we don't allow time-dependent boundary domains,
         // we need to check if our parents are consistent.
         if (!_children_on_boundary)
         {
           // If we're on this external boundary then we share this
           // external boundary id
           if (elem->neighbor_ptr(side) == nullptr)
             {
               returnval.push_back(side);
               continue;
             }
 
           // 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 && !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)
             returnval.push_back(side);
         }
         // Otherwise we trust what we got and return the side
         else
           returnval.push_back(side);
       }
   }
 
 #ifdef LIBMESH_ENABLE_AMR
   // We might have instances (especially with moving boundary domains) when we
   // query the parent boundary ID on a child.
   if (_children_on_boundary && elem->level() != 0)
   {
     for (auto side : make_range(elem->n_sides()))
     {
       const Elem * p = elem;
       while (p->parent() != nullptr)
       {
         const Elem * parent = p->parent();
         // First we make sure the parent shares this side
         if (parent->is_child_on_side(parent->which_child_am_i(p), side))
         {
           // parent may have multiple boundary ids
           for (const auto & pr : as_range(_boundary_side_id.equal_range(parent)))
           {
             // if this is true we found the requested boundary_id
             // of the element and want to add the side to the vector. We
             // also need to check if the side is already in the vector. This might
             // happen if the child inherits the boundary from the parent.
             if (pr.second.first == side && pr.second.second == boundary_id_in &&
                 std::find(returnval.begin(), returnval.end(), side) == returnval.end())
               returnval.push_back(side);
           }
         }
         // If the parent is not on the same side, other ancestors won't be on the same side either
         else
           break;
         p = parent;
       }
     }
   }
 #endif
 
   return returnval;
 }

◆ 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 3246 of file boundary_info.C.

References _ss_id_to_name.

Referenced by libMesh::AbaqusIO::assign_sideset_ids(), libMesh::MeshTools::Generation::build_cube(), DisjointNeighborTest::build_four_disjoint_elems(), build_side_list_from_node_list(), DisjointNeighborTest::build_split_mesh_with_interface(), DisjointNeighborTest::build_two_disjoint_elems(), libMesh::UNVIO::groups_in(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::GmshIO::read_mesh(), MeshStitchTest::renameAndShift(), DisjointNeighborTest::testDisjointNeighborConflictError(), MeshInputTest::testGmshBCIDOverlap(), BoundaryInfoTest::testNameCopying(), BoundaryInfoTest::testRenumber(), BoundaryInfoTest::testSelectiveRenumber(), DisjointNeighborTest::testStitchCrossMesh(), and WriteSidesetData::testWriteImpl().

 {
   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 444 of file boundary_info.C.

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

Referenced by main(), and 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 457 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.

We'll use a temporary MeshSerializer here, but as soon as we unserialize we'll be turning a bunch of interior_parent() links into dangling pointers, and it won't be easy to tell which. So we'll keep around a distributed copy for that case, and query it to fix up interior_parent() links as necessary.

We'll also need to make sure to unserialize the mesh before we prepare the boundary mesh for use, or the prepare_for_use() call on a refined boundary mesh will happily notice that it can find and restore some refined elements' interior_parent pointers, not knowing that those interior parents are about to go remote.

Re-create the boundary mesh.

Definition at line 471 of file boundary_info.C.

 {
   LOG_SCOPE("sync()", "BoundaryInfo");
 
   boundary_mesh.clear();
 
   if (!_mesh->is_serial())
     boundary_mesh.delete_remote_elements();
 
   std::unique_ptr<MeshBase> mesh_copy;
   if (boundary_mesh.is_serial() && !_mesh->is_serial())
     mesh_copy = _mesh->clone();
 
   auto serializer = std::make_unique<MeshSerializer>
     (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;
 
   this->_find_id_maps(requested_boundary_ids, 0, &node_id_map, 0, nullptr, 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);
         }
     }
 
   // Add the elements. When syncing a boundary mesh, we also store the
   // parent side ids in addition to the interior_parent pointers,
   // since this information is frequently needed on boundary meshes.
   this->add_elements(requested_boundary_ids,
                      boundary_mesh,
                      subdomains_relative_to,
                      /*store_parent_side_ids=*/true);
 
   // 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);
         }
     }
 
   // The new elements might have interior parent pointers aimed at
   // _mesh elements which are about to go remote, and we don't to
   // leave those pointers dangling.  Fix them up if needed.
   if (mesh_copy.get())
     {
       for (auto & new_elem : boundary_mesh.element_ptr_range())
         {
           const dof_id_type interior_parent_id =
             new_elem->interior_parent()->id();
 
           if (!mesh_copy->query_elem_ptr(interior_parent_id))
             new_elem->set_interior_parent
               (const_cast<RemoteElem *>(remote_elem));
         }
     }
 
   // Don't repartition this mesh; we want it to stay in sync with the
   // interior partitioning.
   boundary_mesh.partitioner().reset(nullptr);
 
   // Deserialize the interior mesh before the boundary mesh
   // prepare_for_use() can come to erroneous conclusions about which
   // of its elements are semilocal
   serializer.reset();
 
   // Make boundary_mesh nodes and elements contiguous
   boundary_mesh.prepare_for_use();
 
   // and finally distribute element partitioning to the nodes
   Partitioner::set_node_processor_ids(boundary_mesh);
 }

◆ synchronize_global_id_set()

void libMesh::BoundaryInfo::synchronize_global_id_set ( )

Synchronizes the boundary_ids set on each processor to determine global_boundary_ids.

This may be necessary after use of renumber_*() functions, which perform only local operations, if get_global_boundary_ids() is to be used without a full regenerate_id_sets() call first.

Definition at line 431 of file boundary_info.C.

References _boundary_ids, libMesh::ParallelObject::_communicator, _global_boundary_ids, _mesh, libMesh::MeshBase::_preparation, libMesh::MeshBase::Preparation::has_boundary_id_sets, libMesh::MeshBase::is_serial(), libMesh::libmesh_assert(), and TIMPI::Communicator::set_union().

Referenced by regenerate_id_sets(), and BoundaryInfoTest::testSelectiveRenumber().

 {
   // Handle global data
   _global_boundary_ids = _boundary_ids;
   libmesh_assert(_mesh);
   if (!_mesh->is_serial())
     _communicator.set_union(_global_boundary_ids);
 
   _mesh->_preparation.has_boundary_id_sets = true;
 }

◆ transfer_boundary_ids_from_children()

void libMesh::BoundaryInfo::transfer_boundary_ids_from_children ( const Elem *const parent )

Update parent's boundary id list so that this information is consistent with its children.

This is useful when _children_on_boundary = true, and is used when the element is about to get coarsened i.e., in MeshRefinement::_coarsen_elements()

Specifically, when we coarsen an element whose children have different boundary ids. In such scenarios, the parent will inherit the children's boundaries if at least 50% them own a boundary while sharing the side of the parent.

Definition at line 2545 of file boundary_info.C.

References _boundary_side_id, _children_on_boundary, libMesh::Elem::active(), add_side(), libMesh::as_range(), libMesh::Elem::child_ptr(), libMesh::Elem::COARSEN_INACTIVE, libMesh::Elem::dim(), libMesh::Elem::is_child_on_side(), libMesh::make_range(), libMesh::Elem::n_children(), libMesh::Elem::n_sides(), libMesh::Utility::pow(), and libMesh::Elem::refinement_flag().

Referenced by libMesh::MeshRefinement::_coarsen_elements().

 {
   // this is only needed when we allow boundary to be associated with children elements
   // also, we only transfer the parent's boundary ids when we are actually coarsen the child element
   if (!_children_on_boundary ||
       !(!parent->active() && parent->refinement_flag() == Elem::COARSEN_INACTIVE))
     return;
 
   // We assume that edges can be divided ito two pieces, while triangles and
   // quads can be divided into four smaller areas. This is double because we'll need
   // to convert the ratio of the children with given boundary id to a double.
   const double number_of_sides_on_children = std::pow(2, parent->dim()-1);
 
   // In this case the input argument elem is the parent element. We need to check all of its sides
   // to grab any potential boundary ids.
   for (unsigned int side_i = 0; side_i < parent->n_sides(); ++side_i)
   {
     // An temporary storage to count how many times the children's boundaries occur. the general
     // consensus is that if the boundary occurs more than once we propagate upon coarsening. Otherwise,
     // it will get deleted.
     std::map<unsigned short int, unsigned short int> boundary_counts;
 
     for (const auto & child_i : make_range(parent->n_children()))
     {
       // We only need to check the children which share the side
       if (parent->is_child_on_side(child_i, side_i))
       {
         // Fetching the boundary tags on the child's side
         for (const auto & pr : as_range(_boundary_side_id.equal_range(parent->child_ptr(child_i))))
         {
           // Making sure we are on the same boundary
           if (pr.second.first == side_i)
             ++boundary_counts[pr.second.second];
         }
       }
     }
 
     // This is where the decision is made. If 50% of the children have the tags,
     // we propagate them upwards upon coarsening. Otherwise, they are deleted.
     for (const auto & boundary : boundary_counts)
       if (boundary.second / number_of_sides_on_children > 0.5)
         this->add_side(parent, side_i, boundary.first);
   }
 
   for (const auto & child_i : make_range(parent->n_children()))
     this->remove(parent->child_ptr(child_i));
 }

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 984 of file boundary_info.h.

Referenced by add_edge(), build_edge_list(), clear(), edge_boundary_ids(), get_edgeset_map(), libmesh_assert_valid_multimaps(), n_edge_conds(), operator=(), operator==(), print_info(), print_summary(), raw_edge_boundary_ids(), regenerate_id_sets(), remove(), remove_edge(), remove_edge_id(), renumber_edge_id(), and renumber_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.

This only contains information related to this process's local and ghosted elements

Definition at line 1018 of file boundary_info.h.

Referenced by add_edge(), add_node(), add_shellface(), add_side(), clear(), get_boundary_ids(), n_boundary_ids(), operator=(), operator==(), regenerate_id_sets(), remove_edge_id(), remove_node_id(), remove_shellface_id(), remove_side_id(), renumber_edge_id(), renumber_id(), renumber_node_id(), renumber_shellface_id(), renumber_side_id(), sync(), and synchronize_global_id_set().

◆ _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 976 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(), get_nodeset_map(), has_boundary_id(), libmesh_assert_valid_multimaps(), n_boundary_ids(), n_nodeset_conds(), operator=(), operator==(), parallel_sync_node_ids(), print_info(), print_summary(), regenerate_id_sets(), remove(), remove_node(), remove_node_id(), renumber_id(), and renumber_node_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 992 of file boundary_info.h.

Referenced by add_shellface(), build_shellface_boundary_ids(), build_shellface_list(), clear(), libmesh_assert_valid_multimaps(), n_shellface_conds(), operator=(), operator==(), print_info(), print_summary(), raw_shellface_boundary_ids(), regenerate_id_sets(), remove(), remove_shellface(), remove_shellface_id(), renumber_id(), renumber_shellface_id(), 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 1000 of file boundary_info.h.

Referenced by add_side(), boundary_ids(), build_active_side_list(), build_node_list_from_side_list(), build_side_boundary_ids(), build_side_list(), clear(), clear_stitched_boundary_side_ids(), get_sideset_map(), libmesh_assert_valid_multimaps(), n_boundary_conds(), operator=(), operator==(), parallel_sync_side_ids(), print_info(), print_summary(), raw_boundary_ids(), regenerate_id_sets(), remove(), remove_side(), remove_side_id(), renumber_id(), renumber_side_id(), side_boundary_ids(), side_with_boundary_id(), sides_with_boundary_id(), and transfer_boundary_ids_from_children().

◆ _children_on_boundary

bool libMesh::BoundaryInfo::_children_on_boundary

private

Definition at line 1007 of file boundary_info.h.

Referenced by add_side(), allow_children_on_boundary_side(), boundary_ids(), is_children_on_boundary_side(), operator=(), operator==(), raw_boundary_ids(), side_boundary_ids(), side_with_boundary_id(), sides_with_boundary_id(), and transfer_boundary_ids_from_children().

◆ _communicator

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

protectedinherited

Definition at line 120 of file parallel_object.h.

Referenced by libMesh::EquationSystems::build_parallel_elemental_solution_vector(), libMesh::EquationSystems::build_parallel_solution_vector(), libMesh::StaticCondensation::close(), libMesh::ParallelObject::comm(), libMesh::CondensedEigenSystem::initialize_condensed_matrices(), libMesh::ParallelObject::n_processors(), libMesh::ParallelObject::operator=(), libMesh::ParallelObject::processor_id(), regenerate_id_sets(), libMesh::StaticCondensationDofMap::reinit(), and synchronize_global_id_set().

◆ _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.

This only contains information related to this process's local and ghosted elements

Definition at line 1052 of file boundary_info.h.

Referenced by add_edge(), clear(), get_edge_boundary_ids(), operator=(), operator==(), regenerate_id_sets(), remove_edge_id(), remove_node_id(), remove_shellface_id(), remove_side_id(), renumber_edge_id(), renumber_id(), renumber_node_id(), renumber_shellface_id(), and renumber_side_id().

◆ _es_id_to_name

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

private

This structure maintains the mapping of named edge sets for file formats (Exodus, Gmsh) that support this.

This data is global in nature, meaning it should be an aggregate of information across processors

Definition at line 1102 of file boundary_info.h.

Referenced by clear(), edgeset_name(), get_edgeset_name(), get_edgeset_name_map(), get_id_by_name(), operator=(), operator==(), regenerate_id_sets(), remove_edge_id(), renumber_edge_id(), renumber_id(), and set_edgeset_name_map().

◆ _global_boundary_ids

std::set<boundary_id_type> libMesh::BoundaryInfo::_global_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.

Unlike _boundary_ids, this member should contain boundary ids from across all processors after the mesh is prepared

Definition at line 1030 of file boundary_info.h.

Referenced by get_global_boundary_ids(), operator=(), operator==(), remove_edge_id(), remove_id(), remove_node_id(), remove_shellface_id(), remove_side_id(), and synchronize_global_id_set().

◆ _mesh

MeshBase* libMesh::BoundaryInfo::_mesh

private

A pointer to the Mesh this boundary info pertains to.

Definition at line 969 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(), get_global_boundary_ids(), n_boundary_conds(), n_edge_conds(), n_nodeset_conds(), n_shellface_conds(), operator=(), operator==(), parallel_sync_node_ids(), parallel_sync_side_ids(), regenerate_id_sets(), set_mesh(), sync(), and synchronize_global_id_set().

◆ _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.

This only contains information related to this process's local and ghosted elements

Definition at line 1063 of file boundary_info.h.

Referenced by add_node(), clear(), get_node_boundary_ids(), operator=(), operator==(), regenerate_id_sets(), remove_edge_id(), remove_node_id(), remove_shellface_id(), remove_side_id(), renumber_edge_id(), renumber_id(), renumber_node_id(), renumber_shellface_id(), and renumber_side_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 (Exodus, Gmsh) that support this.

This data is global in nature, meaning it should be an aggregate of information across processors

Definition at line 1093 of file boundary_info.h.

Referenced by clear(), get_id_by_name(), get_nodeset_name(), get_nodeset_name_map(), nodeset_name(), operator=(), operator==(), regenerate_id_sets(), remove_node_id(), renumber_id(), renumber_node_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.

This only contains information related to this process's local and ghosted elements

Definition at line 1075 of file boundary_info.h.

Referenced by add_shellface(), clear(), get_shellface_boundary_ids(), operator=(), operator==(), regenerate_id_sets(), remove_edge_id(), remove_node_id(), remove_shellface_id(), remove_side_id(), renumber_edge_id(), renumber_id(), renumber_node_id(), renumber_shellface_id(), and renumber_side_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.

This only contains information related to this process's local and ghosted elements

Definition at line 1041 of file boundary_info.h.

Referenced by add_side(), clear(), get_side_boundary_ids(), operator=(), operator==(), regenerate_id_sets(), remove_edge_id(), remove_node_id(), remove_shellface_id(), remove_side_id(), renumber_edge_id(), renumber_id(), renumber_node_id(), renumber_shellface_id(), and renumber_side_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 (Exodus, Gmsh) that support this.

This data is global in nature, meaning it should be an aggregate of information across processors

Definition at line 1084 of file boundary_info.h.

Referenced by clear(), get_id_by_name(), get_sideset_name(), get_sideset_name_map(), operator=(), operator==(), regenerate_id_sets(), remove_side_id(), renumber_id(), renumber_side_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 912 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(), libMesh::MeshTools::Generation::build_cube(), clear_stitched_boundary_side_ids(), libMesh::MeshTools::Modification::flatten(), get_id_by_name(), libMesh::HDGProblem::init(), libMesh::RBEIMConstruction::initialize_qp_data(), libMesh::Poly2TriTriangulator::insert_refinement_points(), libMesh::MeshTools::libmesh_assert_valid_boundary_ids(), main(), libMesh::UnstructuredMesh::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:

include/mesh/boundary_info.h
src/mesh/boundary_info.C

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ BCTuple

◆ NodeBCTuple

Member Enumeration Documentation

◆ BCTupleSortBy

◆ NodeBCTupleSortBy

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]

◆ allow_children_on_boundary_side()

◆ boundary_ids() [1/2]

◆ boundary_ids() [2/2]

◆ build_active_side_list()

◆ build_edge_list()

◆ build_node_boundary_ids()

◆ build_node_list()

◆ build_node_list_from_side_list()

◆ build_shellface_boundary_ids()

◆ build_shellface_list()

◆ build_side_boundary_ids()

◆ build_side_list()

◆ build_side_list_from_node_list()

◆ clear()

◆ clear_boundary_node_ids()

◆ clear_stitched_boundary_side_ids()

◆ comm()

◆ copy_boundary_ids()

◆ edge_boundary_ids()

◆ edgeset_name()

◆ get_boundary_ids()

◆ get_edge_boundary_ids()

◆ get_edgeset_map()

◆ get_edgeset_name()

◆ get_edgeset_name_map()

◆ get_global_boundary_ids()

◆ get_id_by_name()

◆ get_node_boundary_ids()

◆ get_nodeset_map()

◆ get_nodeset_name()

◆ get_nodeset_name_map()

◆ get_shellface_boundary_ids()

◆ get_side_and_node_maps()

◆ get_side_boundary_ids()

◆ get_sideset_map()

◆ get_sideset_name()

◆ get_sideset_name_map()

◆ has_boundary_id() [1/2]

◆ has_boundary_id() [2/2]

◆ is_children_on_boundary_side()

◆ libmesh_assert_valid_multimaps()

◆ n_boundary_conds()

◆ n_boundary_ids() [1/3]

◆ n_boundary_ids() [2/3]

◆ n_boundary_ids() [3/3]

◆ n_edge_boundary_ids()