Classes
struct	ElemSidePair

Functions
void	mergeBoundaryIDsWithSameName (MeshBase &mesh)
	Merges the boundary IDs of boundaries that have the same names but different IDs. More...

void	changeBoundaryId (MeshBase &mesh, const libMesh::boundary_id_type old_id, const libMesh::boundary_id_type new_id, bool delete_prev)
	Changes the old boundary ID to a new ID in the mesh. More...

void	changeSubdomainId (MeshBase &mesh, const subdomain_id_type old_id, const subdomain_id_type new_id)
	Changes the old subdomain ID to a new ID in the mesh. More...

std::vector< BoundaryID >	getBoundaryIDs (const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown, const std::set< BoundaryID > &mesh_boundary_ids)
	Gets the boundary IDs with their names. More...

std::vector< BoundaryID >	getBoundaryIDs (const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown)
	Gets the boundary IDs with their names. More...

std::set< BoundaryID >	getBoundaryIDSet (const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown)
	Gets the boundary IDs into a set with their names. More...

BoundaryID	getBoundaryID (const BoundaryName &boundary_name, const MeshBase &mesh)
	Gets the boundary ID associated with the given BoundaryName. More...

SubdomainID	getSubdomainID (const SubdomainName &subdomain_name, const MeshBase &mesh)
	Gets the subdomain ID associated with the given SubdomainName. More...

std::vector< subdomain_id_type >	getSubdomainIDs (const libMesh::MeshBase &mesh, const std::vector< SubdomainName > &subdomain_name)
	Get the associated subdomainIDs for the subdomain names that are passed in. More...

std::set< subdomain_id_type >	getSubdomainIDs (const libMesh::MeshBase &mesh, const std::set< SubdomainName > &subdomain_name)

Point	meshCentroidCalculator (const MeshBase &mesh)
	Calculates the centroid of a MeshBase. More...

Point	boundaryCentroidCalculator (const BoundaryName &boundary, MeshBase &mesh)
	Calculates the centroid of a boundary on a mesh. More...

RealVectorValue	boundaryWeightedNormal (const BoundaryName &boundary, MeshBase &mesh)
	Calculates the side-volume weighted (side-vertex) average normal of a boundary on a mesh. More...

template<typename P , typename C >
void	coordTransformFactor (const P &point, C &factor, const Moose::CoordinateSystemType coord_type, const unsigned int rz_radial_coord=libMesh::invalid_uint)
	Compute a coordinate transformation volume integration factor. More...

template<typename P , typename C >
C	computeDistanceToAxis (const P &point, const Point &origin, const RealVectorValue &direction)
	Computes the distance to a general axis. More...

Real	computeMaxDistanceToAxis (const MeshBase &mesh, const Point &origin, const RealVectorValue &direction)
	Computes the maximum distance from all nodes of a mesh to a general axis. More...

template<typename P , typename C >
void	coordTransformFactorRZGeneral (const P &point, const std::pair< Point, RealVectorValue > &axis, C &factor)
	Computes a coordinate transformation factor for a general axisymmetric axis. More...

void	computeFiniteVolumeCoords (FaceInfo &fi, const Moose::CoordinateSystemType coord_type, const unsigned int rz_radial_coord=libMesh::invalid_uint)

std::unordered_map< dof_id_type, dof_id_type >	getExtraIDUniqueCombinationMap (const MeshBase &mesh, const std::set< SubdomainID > &block_ids, std::vector< ExtraElementIDName > extra_ids)
	Create a new set of element-wise IDs by finding unique combinations of existing extra ID values. More...

bool	isCoPlanar (const std::vector< Point > &vec_pts, const Point plane_nvec, const Point fixed_pt)
	Decides whether all the Points of a vector of Points are in a plane that is defined by a normal vector and an inplane Point. More...

bool	isCoPlanar (const std::vector< Point > &vec_pts, const Point plane_nvec)
	Decides whether all the Points of a vector of Points are in a plane with a given normal vector. More...

bool	isCoPlanar (const std::vector< Point > &vec_pts)
	Decides whether all the Points of a vector of Points are coplanar. More...

SubdomainID	getNextFreeSubdomainID (MeshBase &input_mesh)
	Checks input mesh and returns max(block ID) + 1, which represents a block ID that is not currently in use in the mesh. More...

BoundaryID	getNextFreeBoundaryID (MeshBase &input_mesh)
	Checks input mesh and returns the largest boundary ID in the mesh plus one, which is a boundary ID in the mesh that is not currently in use. More...

bool	hasSubdomainID (const MeshBase &input_mesh, const SubdomainID &id)
	Whether a particular subdomain ID exists in the mesh. More...

bool	hasSubdomainName (const MeshBase &input_mesh, const SubdomainName &name)
	Whether a particular subdomain name exists in the mesh. More...

bool	hasBoundaryID (const MeshBase &input_mesh, const BoundaryID id)
	Whether a particular boundary ID exists in the mesh. More...

bool	hasBoundaryName (const MeshBase &mesh, const BoundaryName &name)
	Whether a particular boundary name exists in the mesh. More...

bool	hasBoundaryNameOrID (const MeshBase &mesh, const BoundaryName &name_or_id)
	Whether a particular boundary name or ID exists in the mesh. More...

void	makeOrderedNodeList (std::vector< std::pair< dof_id_type, dof_id_type >> &node_assm, std::vector< dof_id_type > &elem_id_list, std::vector< dof_id_type > &midpoint_node_list, std::vector< dof_id_type > &ordered_node_list, std::vector< dof_id_type > &ordered_elem_id_list)
	Convert a list of sides in the form of a vector of pairs of node ids into a list of ordered nodes based on connectivity. More...

void	makeOrderedNodeList (std::vector< std::pair< dof_id_type, dof_id_type >> &node_assm, std::vector< dof_id_type > &elem_id_list, std::vector< dof_id_type > &ordered_node_list, std::vector< dof_id_type > &ordered_elem_id_list)
	Convert a list of sides in the form of a vector of pairs of node ids into a list of ordered nodes based on connectivity. More...

template<typename T , typename Q >
Q	getIDFromName (const T &name)
	Converts a given name (BoundaryName or SubdomainName) that is known to only contain digits into a corresponding ID (BoundaryID or SubdomainID) and performs bounds checking to ensure that overflow doesn't happen. More...

void	swapNodesInElem (Elem &elem, const unsigned int nd1, const unsigned int nd2)
	Swap two nodes within an element. More...

template<typename T >
void	idSwapParametersProcessor (const std::string &class_name, const std::string &id_name, const std::vector< std::vector< T >> &id_swaps, std::vector< std::unordered_map< T, T >> &id_swap_pairs, const unsigned int row_index_shift=0)
	Reprocess the swap related input parameters to make pairs out of them to ease further processing. More...

void	extraElemIntegerSwapParametersProcessor (const std::string &class_name, const unsigned int num_sections, const unsigned int num_integers, const std::vector< std::vector< std::vector< dof_id_type >>> &elem_integers_swaps, std::vector< std::unordered_map< dof_id_type, dof_id_type >> &elem_integers_swap_pairs)
	Reprocess the elem_integers_swaps into maps so they are easier to use. More...

std::unique_ptr< ReplicatedMesh >	buildBoundaryMesh (const MeshBase &input_mesh, const boundary_id_type boundary_id)
	Build a lower-dimensional mesh from a boundary of an input mesh Note: The lower-dimensional mesh will only have one subdomain and one boundary. More...

std::unique_ptr< ReplicatedMesh >	buildLoopBoundaryOf2DMesh (const MeshBase &input_mesh, const boundary_id_type boundary_id)
	Build a loop mesh of edges from the contiguous 2D boundary of 2D input mesh Note: The lower-dimensional mesh will only have one subdomain. More...

std::unordered_map< dof_id_type, std::unordered_set< dof_id_type > >	buildBoundaryNodeToElemMap (const MeshBase &input_mesh, const boundary_id_type boundary_id)
	Build a map from the node ids to all element ids they are part of for the nodes on a particular nodeset. More...

std::set< dof_id_type >	getBoundaryNodes (const MeshBase &mesh, const BoundaryID boundary_id)
	Get all the nodes on that particular boundary, whether a nodeset or a sideset. More...

void	createSubdomainFromSidesets (MeshBase &mesh, std::vector< BoundaryName > boundary_names, const SubdomainID new_subdomain_id, const SubdomainName new_subdomain_name, const std::string type_name)
	Create a new subdomain by generating new side elements from a list of sidesets in a given mesh. More...

void	convertBlockToMesh (MeshBase &source_mesh, MeshBase &target_mesh, const std::vector< SubdomainName > &target_blocks)
	Convert a list of blocks in a given mesh to a standalone new mesh. More...

void	copyIntoMesh (MeshGenerator &mg, UnstructuredMesh &destination, const UnstructuredMesh &source, const bool avoid_merging_subdomains, const bool avoid_merging_boundaries, const Parallel::Communicator &communicator)
	Helper function for copying one mesh into another. More...

void	buildPolyLineMesh (MeshBase &mesh, const std::vector< Point > &points, const bool loop, const BoundaryName &start_boundary, const BoundaryName &end_boundary, const std::vector< unsigned int > &nums_edges_between_points)
	Generates meshes from edges connecting a list of points. More...

void	buildPolyLineMesh (MeshBase &mesh, const std::vector< Point > &points, const std::vector< Point > &mid_points, const bool loop, const BoundaryName &start_boundary, const BoundaryName &end_boundary, const std::vector< unsigned int > &nums_edges_between_points)
	Generates meshes from edges connecting a list of points, with optional midpoints to produce Edge3 elements so as to enable quadratic meshing. More...

void	buildPolyLineMesh (MeshBase &mesh, const std::vector< Point > &points, const bool loop, const BoundaryName &start_boundary, const BoundaryName &end_boundary, const Real max_elem_size)
	Generates meshes from edges connecting a list of points. More...

void	addExternalBoundary (MeshBase &mesh, const BoundaryID extern_bid, bool &has_external_bid)
	Adds a sideset for the external boundary of the mesh (e.g. More...

void	mergeBoundaryIDsWithSameName (MeshBase &mesh)

void	changeBoundaryId (MeshBase &mesh, const boundary_id_type old_id, const boundary_id_type new_id, bool delete_prev)

BoundaryID	getBoundaryID (const BoundaryName &boundary_name, const MeshBase &mesh)

SubdomainID	getSubdomainID (const SubdomainName &subdomain_name, const MeshBase &mesh)

void	changeSubdomainId (MeshBase &mesh, const subdomain_id_type old_id, const subdomain_id_type new_id)

Point	meshCentroidCalculator (const MeshBase &mesh)

Point	boundaryCentroidCalculator (const BoundaryName &boundary, MeshBase &mesh)

RealVectorValue	boundaryWeightedNormal (const BoundaryName &boundary, MeshBase &mesh)

Real	computeMaxDistanceToAxis (const MeshBase &mesh, const Point &origin, const RealVectorValue &direction)

std::unordered_map< dof_id_type, dof_id_type >	getExtraIDUniqueCombinationMap (const MeshBase &mesh, const std::set< SubdomainID > &block_ids, std::vector< ExtraElementIDName > extra_ids)

bool	isCoPlanar (const std::vector< Point > &vec_pts, const Point plane_nvec, const Point fixed_pt)

bool	isCoPlanar (const std::vector< Point > &vec_pts, const Point plane_nvec)

bool	isCoPlanar (const std::vector< Point > &vec_pts)

SubdomainID	getNextFreeSubdomainID (MeshBase &input_mesh)

BoundaryID	getNextFreeBoundaryID (MeshBase &input_mesh)

bool	hasSubdomainID (const MeshBase &input_mesh, const SubdomainID &id)

bool	hasSubdomainName (const MeshBase &input_mesh, const SubdomainName &name)

bool	hasBoundaryID (const MeshBase &input_mesh, const BoundaryID id)

bool	hasBoundaryName (const MeshBase &mesh, const BoundaryName &name)

bool	hasBoundaryNameOrID (const MeshBase &mesh, const BoundaryName &name_or_id)

void	swapNodesInElem (Elem &elem, const unsigned int nd1, const unsigned int nd2)

std::unique_ptr< ReplicatedMesh >	buildBoundaryMesh (const MeshBase &input_mesh, const boundary_id_type boundary_id)

std::unique_ptr< ReplicatedMesh >	buildLoopBoundaryOf2DMesh (const MeshBase &input_mesh, const boundary_id_type boundary_id)

std::unordered_map< dof_id_type, std::unordered_set< dof_id_type > >	buildBoundaryNodeToElemMap (const MeshBase &input_mesh, const boundary_id_type boundary_id)

std::set< dof_id_type >	getBoundaryNodes (const MeshBase &mesh, const BoundaryID boundary_id)

void	createSubdomainFromSidesets (MeshBase &mesh, std::vector< BoundaryName > boundary_names, const SubdomainID new_subdomain_id, const SubdomainName new_subdomain_name, const std::string type_name)

void	convertBlockToMesh (MeshBase &source_mesh, MeshBase &target_mesh, const std::vector< SubdomainName > &target_blocks)

void	copyIntoMesh (MeshGenerator &mg, UnstructuredMesh &destination, const UnstructuredMesh &source, const bool avoid_merging_subdomains, const bool avoid_merging_boundaries, const Parallel::Communicator &communicator)

void	buildPolyLineMesh (MeshBase &mesh, const std::vector< Point > &points, const std::vector< Point > &mid_points, const bool loop, const BoundaryName &start_boundary, const BoundaryName &end_boundary, const std::vector< unsigned int > &nums_edges_between_points)

void	buildPolyLineMesh (MeshBase &mesh, const std::vector< Point > &points, const bool loop, const BoundaryName &start_boundary, const BoundaryName &end_boundary, const std::vector< unsigned int > &nums_edges_between_points)

void	buildPolyLineMesh (MeshBase &mesh, const std::vector< Point > &points, const bool loop, const BoundaryName &start_boundary, const BoundaryName &end_boundary, const Real max_elem_size)

void	addExternalBoundary (MeshBase &mesh, const BoundaryID extern_bid, bool &has_external_bid)

Function Documentation

◆ addExternalBoundary() [1/2]

void MooseMeshUtils::addExternalBoundary	(	MeshBase &	mesh,
		const BoundaryID	extern_bid,
		bool &	has_external_bid
	)

Adds a sideset for the external boundary of the mesh (e.g.

all element sides with no neighbors)

Parameters

mesh	the mesh to modify
extern_bid	the ID to assign to the external boundary
has_external_bid	false if all elements of the mesh are internal (for example a sphere shell)

Referenced by XYTriangleBoundaryLayerGenerator::generate(), XYDelaunayGenerator::generate(), and SurfaceSubdomainsDelaunayRemesher::generate().

◆ addExternalBoundary() [2/2]

void MooseMeshUtils::addExternalBoundary	(	MeshBase &	mesh,
		const BoundaryID	extern_bid,
		bool &	has_external_bid
	)

Definition at line 1557 of file MooseMeshUtils.C.

 {
   auto & binfo = mesh.get_boundary_info();
   for (const auto & elem : mesh.active_element_ptr_range())
     for (const auto & i_side : elem->side_index_range())
       if (elem->neighbor_ptr(i_side) == nullptr)
       {
         has_external_bid = true;
         binfo.add_side(elem, i_side, extern_bid);
       }
 }

◆ boundaryCentroidCalculator() [1/2]

Point MooseMeshUtils::boundaryCentroidCalculator	(	const BoundaryName &	boundary,
		MeshBase &	mesh
	)

Calculates the centroid of a boundary on a mesh.

Parameters

boundary	boundary to compute the centroid of
mesh	input mesh holding the boundary whose centroid needs to be calculated

Returns: a Point corresponding to the boundary centroid

Referenced by BSplineCurveGenerator::endPoint(), and BSplineCurveGenerator::startPoint().

◆ boundaryCentroidCalculator() [2/2]

Point MooseMeshUtils::boundaryCentroidCalculator	(	const BoundaryName &	boundary,
		MeshBase &	mesh
	)

Definition at line 297 of file MooseMeshUtils.C.

 {
   // Need boundaries to be synchronized
   if (!mesh.preparation().has_boundary_id_sets)
     mesh.get_boundary_info().synchronize_global_id_set();
   BoundaryInfo & mesh_boundary_info = mesh.get_boundary_info();
   boundary_id_type boundary_id = mesh_boundary_info.get_id_by_name(boundary);
   const auto side_list = mesh_boundary_info.build_side_list();
 
   // Initialize sums
   Real volume_sum = 0;
   Point volume_weighted_centroid_sum(0, 0, 0);
 
   for (const auto & [eid, side_i, bid] : side_list)
   {
     if (bid != boundary_id)
       continue;
 
     // Get the side
     const auto elem = mesh.elem_ptr(eid);
     const auto side = elem->side_ptr(side_i);
 
     volume_sum += side->volume();
     volume_weighted_centroid_sum += side->volume() * side->true_centroid();
   }
   // Sum across processes
   mesh.comm().sum(volume_weighted_centroid_sum);
   mesh.comm().sum(volume_sum);
 
   return volume_weighted_centroid_sum / volume_sum;
 }

◆ boundaryWeightedNormal() [1/2]

RealVectorValue MooseMeshUtils::boundaryWeightedNormal	(	const BoundaryName &	boundary,
		MeshBase &	mesh
	)

Calculates the side-volume weighted (side-vertex) average normal of a boundary on a mesh.

Parameters

boundary	boundary to compute the weighted normal of
mesh	input mesh holding the boundary whose averaged normal needs to be calculated

Returns: a Point corresponding to the boundary weighted normal

Referenced by BSplineCurveGenerator::endDirection(), and BSplineCurveGenerator::startDirection().

◆ boundaryWeightedNormal() [2/2]

RealVectorValue MooseMeshUtils::boundaryWeightedNormal	(	const BoundaryName &	boundary,
		MeshBase &	mesh
	)

Definition at line 330 of file MooseMeshUtils.C.

 {
   // Need boundaries to be synchronized
   if (!mesh.preparation().has_boundary_id_sets)
     mesh.get_boundary_info().synchronize_global_id_set();
   BoundaryInfo & mesh_boundary_info = mesh.get_boundary_info();
   boundary_id_type boundary_id = mesh_boundary_info.get_id_by_name(boundary);
   const auto side_list = mesh_boundary_info.build_side_list();
 
   // Initialize sums
   Real volume_sum = 0;
   RealVectorValue volume_weighted_normal_sum(0, 0, 0);
 
   for (const auto & [eid, side_i, bid] : side_list)
   {
     if (bid != boundary_id)
       continue;
 
     // Get the side
     const auto elem = mesh.elem_ptr(eid);
     const auto side = elem->side_ptr(side_i);
 
     volume_sum += side->volume();
     volume_weighted_normal_sum += side->volume() * elem->side_vertex_average_normal(side_i);
   }
   // Sum across processes
   mesh.comm().sum(volume_weighted_normal_sum);
   mesh.comm().sum(volume_sum);
 
   return volume_weighted_normal_sum / volume_sum;
 }

◆ buildBoundaryMesh() [1/2]

std::unique_ptr<ReplicatedMesh> MooseMeshUtils::buildBoundaryMesh	(	const MeshBase &	input_mesh,
		const boundary_id_type	boundary_id
	)

Build a lower-dimensional mesh from a boundary of an input mesh Note: The lower-dimensional mesh will only have one subdomain and one boundary.

Error will be thrown if the mesh does not have the boundary. This function works only with replicated mesh, for similar functionality with distributed meshes, please refer to LowerDBlockFromSidesetGenerator generator.

Parameters

input_mesh	The input mesh
boundary_id	The boundary id

◆ buildBoundaryMesh() [2/2]

std::unique_ptr<ReplicatedMesh> MooseMeshUtils::buildBoundaryMesh	(	const MeshBase &	input_mesh,
		const boundary_id_type	boundary_id
	)

Definition at line 705 of file MooseMeshUtils.C.

 {
   if (!input_mesh.is_serial())
     ::mooseError("Input mesh should be serialized for extracting the boundary mesh.\nInput mesh:" +
                  input_mesh.get_info());
   auto poly_mesh = std::make_unique<ReplicatedMesh>(input_mesh.comm());
 
   auto side_list = input_mesh.get_boundary_info().build_side_list();
 
   std::unordered_map<dof_id_type, dof_id_type> old_new_node_map;
   for (const auto & [eid, side_i, bid] : side_list)
   {
     if (bid != boundary_id)
       continue;
 
     // Get the side
     const auto elem = input_mesh.elem_ptr(eid);
     const auto side = elem->side_ptr(side_i);
     auto side_elem = elem->build_side_ptr(side_i);
     auto copy = side_elem->build(side_elem->type());
 
     for (const auto i : side_elem->node_index_range())
     {
       auto & n = side_elem->node_ref(i);
 
       if (old_new_node_map.count(n.id()))
         copy->set_node(i, poly_mesh->node_ptr(old_new_node_map[n.id()]));
       else
       {
         Node * node = poly_mesh->add_point(side_elem->point(i));
         copy->set_node(i, node);
         old_new_node_map[n.id()] = node->id();
       }
     }
     poly_mesh->add_elem(copy.release());
   }
   poly_mesh->skip_partitioning(true);
   poly_mesh->prepare_for_use();
   if (poly_mesh->n_elem() == 0)
     mooseError("The input mesh to extract the boundary from does not have a boundary with id ",
                boundary_id,
                ".\n",
                input_mesh);
 
   return poly_mesh;
 }

◆ buildBoundaryNodeToElemMap() [1/2]

std::unordered_map<dof_id_type, std::unordered_set<dof_id_type> > MooseMeshUtils::buildBoundaryNodeToElemMap	(	const MeshBase &	input_mesh,
		const boundary_id_type	boundary_id
	)

Build a map from the node ids to all element ids they are part of for the nodes on a particular nodeset.

Parameters

input_mesh	The input mesh to get the map for
boundary_id	The boundary id of interest

◆ buildBoundaryNodeToElemMap() [2/2]

std::unordered_map<dof_id_type, std::unordered_set<dof_id_type> > MooseMeshUtils::buildBoundaryNodeToElemMap	(	const MeshBase &	input_mesh,
		const boundary_id_type	boundary_id
	)

Definition at line 968 of file MooseMeshUtils.C.

Referenced by buildLoopBoundaryOf2DMesh().

 {
   if (!input_mesh.is_serial())
     ::mooseError(
         "Input 2D mesh should be serialized for extracting the loop boundary mesh.\nInput mesh:" +
         input_mesh.get_info());
 
   // Get all nodes on that boundary
   // Boundary ID might be a sideset or a nodeset, get nodes regardless
   const auto particular_node_ids = getBoundaryNodes(input_mesh, boundary_id);
 
   std::unordered_map<dof_id_type, std::unordered_set<dof_id_type>> nid_to_eids_map;
   // Fill the map from looping over elements
   for (const auto & elem :
        as_range(input_mesh.active_elements_begin(), input_mesh.active_elements_end()))
   {
     for (const auto & nd : elem->node_ref_range())
     {
       // Only add the element id if the node is on the boundary
       if (!particular_node_ids.count(nd.id()))
         continue;
 
       auto & elem_ids = nid_to_eids_map[nd.id()];
       elem_ids.insert(elem->id());
     }
   }
   return nid_to_eids_map;
 }

◆ buildLoopBoundaryOf2DMesh() [1/2]

std::unique_ptr<ReplicatedMesh> MooseMeshUtils::buildLoopBoundaryOf2DMesh	(	const MeshBase &	input_mesh,
		const boundary_id_type	boundary_id
	)

Build a loop mesh of edges from the contiguous 2D boundary of 2D input mesh Note: The lower-dimensional mesh will only have one subdomain.

An error will be thrown if the mesh does not have the boundary. Note: currently, the boundary_id must be a nodeset!

Parameters

input_mesh	The input mesh
boundary_id	The boundary id

Referenced by SurfaceSubdomainsDelaunayRemesher::General2DDelaunay().

◆ buildLoopBoundaryOf2DMesh() [2/2]

std::unique_ptr<ReplicatedMesh> MooseMeshUtils::buildLoopBoundaryOf2DMesh	(	const MeshBase &	input_mesh,
		const boundary_id_type	boundary_id
	)

Definition at line 753 of file MooseMeshUtils.C.

 {
   if (!input_mesh.is_serial())
     ::mooseError(
         "Input 2D mesh should be serialized for extracting the loop boundary mesh.\nInput mesh:" +
         input_mesh.get_info());
   auto edge_mesh = std::make_unique<ReplicatedMesh>(input_mesh.comm());
   auto side_list = input_mesh.get_boundary_info().build_side_list();
   std::set<BoundaryInfo::BCTuple> visited;
   bool already_seen_this_side_tuple = false;
   BoundaryInfo::BCTuple first_side_visited = {libMesh::invalid_uint, 0, 0};
 
   // Helps move elem to elem at a given node
   const auto node_to_elem_map = buildBoundaryNodeToElemMap(input_mesh, boundary_id);
   // Helps check if a node is part of a boundary
   const auto & node_to_bids = input_mesh.get_boundary_info().get_nodeset_map();
 
   // Traverse from the first side (edge) in the side_list that matches the boundary_id
   for (const auto & bside : side_list)
   {
     if (std::get<2>(bside) != boundary_id)
       continue;
 
     // Check that we are not starting 'another' loop
     if (bside != first_side_visited)
     {
       if (visited.size() && !visited.count(bside))
         mooseWarning(
             "Boundary " + std::to_string(boundary_id) +
             " is not a (contiguous) loop. Boundary side: (" + Moose::stringify(bside) +
             ") was not visited after a single pass around the boundary. Boundary sides visited: " +
             Moose::stringify(visited));
       else if (visited.empty())
         first_side_visited = bside;
       else
         continue;
     }
 
     // Form the element to be able to find the side
     // These three variables will be updated while traversing the loop boundary
     const Elem * elem = input_mesh.elem_ptr(std::get<0>(bside));
     auto current_side = std::get<1>(bside);
     auto side_elem = elem->build_side_ptr(current_side);
 
     // 3D elements should not be part of this boundary
     if (elem->dim() != 2)
       mooseError(
           "Finding the loop boundary of a 2D mesh cannot be done with non-2D elements such as ",
           *elem);
 
     // Start from node 0 of the side (on the boundary), set the next node as the other node
     // one that side, and keep going from tht next node
     bool looped_back = false;
     const Node * starting_node = side_elem->node_ptr(0);
     const auto new_mesh_starting_node = edge_mesh->add_point(side_elem->point(0));
     Node * new_first_node = new_mesh_starting_node;
     [[maybe_unused]] dof_id_type first_node_index = starting_node->id();
     dof_id_type second_node_index = input_mesh.node_ptr(side_elem->node_id(1))->id();
 
     while (!looped_back && !already_seen_this_side_tuple)
     {
       if (MooseUtils::absoluteFuzzyEqual(input_mesh.point(second_node_index),
                                          Point(*starting_node)))
         looped_back = true;
 
       // Get the opposite node (the next node) and add it to the edge mesh
       Node * new_second_node = looped_back
                                    ? new_mesh_starting_node
                                    : edge_mesh->add_point(input_mesh.point(second_node_index));
 
       // Add a copy of the edge side element to the mesh
       side_elem = elem->build_side_ptr(current_side);
       auto copy = side_elem->build(side_elem->type());
       copy->set_node(0, new_first_node);
       copy->set_node(1, new_second_node);
       edge_mesh->add_elem(copy.release());
 
       // Make this side as 'visited'
       std::tuple<dof_id_type, unsigned short int, boundary_id_type> bc_tuple = {
           elem->id(), current_side, boundary_id};
       const auto & visit_iter = visited.insert(bc_tuple);
       if (!looped_back && !visit_iter.second)
         already_seen_this_side_tuple = true;
 
       // Find the next element and side_elem
       auto & connected_elems = libmesh_map_find(node_to_elem_map, second_node_index);
       bool found_match = false;
       const auto current_eid = elem->id();
 
       for (const auto eid : connected_elems)
       {
         mooseAssert(!found_match,
                     "We should only find one node on a connected element on this boundary");
         if (eid != current_eid)
         {
           // Update the element (on the input mesh)
           elem = input_mesh.elem_ptr(eid);
 
           // Find the side and the opposite node index in that side
           for (const auto si : elem->side_index_range())
           {
             // Check that second node is on the side
             const auto local_second_node_index =
                 elem->get_node_index(input_mesh.node_ptr(second_node_index));
             // 2 sides should match this
             if (elem->is_node_on_side(local_second_node_index, si))
             {
               // Only one side should be on the same boundary (node is connected to two elements)
               // Form a bc_tuple and check the list of boundary sides
               std::tuple<dof_id_type, unsigned short int, boundary_id_type> side_bc_tuple = {
                   elem->id(), si, boundary_id};
 
               if (std::find(side_list.begin(), side_list.end(), side_bc_tuple) == side_list.end())
                 continue;
 
               // We are on the right boundary, just need to get the other node
               for (const auto local_side_node_id : elem->nodes_on_side(si))
               {
                 const auto side_node_id = elem->node_id(local_side_node_id);
 
                 // Skip current node (use global index to compare)
                 if (side_node_id == second_node_index)
                   continue;
                 mooseAssert(side_node_id != first_node_index,
                             "Somehow looped back in a single element");
 
                 current_side = si;
                 second_node_index = side_node_id;
                 found_match = true;
                 break;
               }
             }
             // No need to examine more sides
             if (found_match)
               break;
           }
 
           // No need to examine more elements
           if (found_match)
             break;
         }
         // next node could be on the same element, just moving on to the next side
         else if (connected_elems.size() == 1)
         {
           elem = input_mesh.elem_ptr(eid);
           const auto local_second_node_index =
               elem->get_node_index(input_mesh.node_ptr(second_node_index));
 
           // Move on to the next side
           for (const auto si : elem->side_index_range())
             if (si != current_side && elem->is_node_on_side(local_second_node_index, si))
             {
               // Check all nodes on that next side
               for (const auto local_side_node_id : elem->nodes_on_side(si))
               {
                 const auto side_node_id = elem->node_id(local_side_node_id);
                 // Skip current node
                 if (side_node_id == second_node_index)
                   continue;
                 mooseAssert((side_node_id != first_node_index) ||
                                 (side_list.size() == elem->n_sides()),
                             "Somehow looped back in a single element");
 
                 // Check all the boundaries the other node (on the edge side) is part of
                 const auto bids_range = node_to_bids.equal_range(input_mesh.node_ptr(side_node_id));
 
                 for (auto iter = bids_range.first; iter != bids_range.second; iter++)
                   if (iter->second == boundary_id)
                   {
                     current_side = si;
                     second_node_index = side_node_id;
                     found_match = true;
                   }
               }
 
               // no need to examine other sides
               if (found_match)
                 break;
             }
         }
       }
 
       // Set current node to opposite node of new element
       // NOTE: do not use new_first_node or new_second_node to search in the input mesh!
       new_first_node = new_second_node;
       first_node_index = second_node_index;
 
       // Handle loop ending criterion
       if (!found_match)
       {
         mooseWarning("Search for next element in loop boundary failed. Is boundary '" +
                          std::to_string(boundary_id) + "' of mesh ",
                      input_mesh,
                      " a loop boundary?");
         break;
       }
     }
   }
 
   if (already_seen_this_side_tuple)
     mooseWarning("Boundary " + std::to_string(boundary_id) +
                  " seems to have cycles. A single-cycle loop should be used");
 
   edge_mesh->skip_partitioning(true);
   edge_mesh->prepare_for_use();
   if (edge_mesh->n_elem() == 0)
     mooseError("The input mesh to extract the boundary from does not have a boundary with id ",
                boundary_id,
                "\n",
                input_mesh);
 
   return edge_mesh;
 }

◆ buildPolyLineMesh() [1/6]

void MooseMeshUtils::buildPolyLineMesh	(	MeshBase &	mesh,
		const std::vector< Point > &	points,
		const bool	loop,
		const BoundaryName &	start_boundary,
		const BoundaryName &	end_boundary,
		const std::vector< unsigned int > &	nums_edges_between_points
	)

Generates meshes from edges connecting a list of points.

Parameters

mesh	The mesh to be built
points	The list of points defining the polyline
loop	Whether the polyline is a closed loop
start_boundary	The boundary name to assign to the start of the polyline (if not a loop)
end_boundary	The boundary name to assign to the end of the polyline (if not a loop)
nums_edges_between_points	The numbers of edges to create between each pair of points (if only one number is given, it is used for all point pairs)

Referenced by BoundaryLayerUtils::buildBoundaryLayerRing(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), and PolyLineMeshGenerator::generate().

◆ buildPolyLineMesh() [2/6]

void MooseMeshUtils::buildPolyLineMesh	(	MeshBase &	mesh,
		const std::vector< Point > &	points,
		const std::vector< Point > &	mid_points,
		const bool	loop,
		const BoundaryName &	start_boundary,
		const BoundaryName &	end_boundary,
		const std::vector< unsigned int > &	nums_edges_between_points
	)

Generates meshes from edges connecting a list of points, with optional midpoints to produce Edge3 elements so as to enable quadratic meshing.

If mid_points is empty, Edge2 elements are produced.

Parameters

mesh	The mesh to be built
points	The list of points defining the polyline
mid_points	The optional list of midpoints corresponding to the segments for quadratic elements. if provided, it must contains exactly one midpoint per segment and nums_edges_between_points must be unity for every segment.
loop	Whether the polyline is a closed loop
start_boundary	The boundary name to assign to the start of the polyline (if not a loop)
end_boundary	The boundary name to assign to the end of the polyline (if not a loop)
nums_edges_between_points	The numbers of edges to create between each pair of points (if only one number is given, it is used for all point pairs)

◆ buildPolyLineMesh() [3/6]

void MooseMeshUtils::buildPolyLineMesh	(	MeshBase &	mesh,
		const std::vector< Point > &	points,
		const bool	loop,
		const BoundaryName &	start_boundary,
		const BoundaryName &	end_boundary,
		const Real	max_elem_size
	)

Generates meshes from edges connecting a list of points.

Note that we do not support max_elem_size and quadratic mid points at the same time as we cannot pre-determine the number of mid points needed for quadratic elements when max_elem_size is specified.

Parameters

mesh	The mesh to be built
points	The list of points defining the polyline
loop	Whether the polyline is a closed loop
start_boundary	The boundary name to assign to the start of the polyline (if not a loop)
end_boundary	The boundary name to assign to the end of the polyline (if not a loop)
max_elem_size	The maximum element size for the mesh

◆ buildPolyLineMesh() [4/6]

void MooseMeshUtils::buildPolyLineMesh	(	MeshBase &	mesh,
		const std::vector< Point > &	points,
		const std::vector< Point > &	mid_points,
		const bool	loop,
		const BoundaryName &	start_boundary,
		const BoundaryName &	end_boundary,
		const std::vector< unsigned int > &	nums_edges_between_points
	)

Definition at line 1411 of file MooseMeshUtils.C.

 {
   mooseAssert(nums_edges_between_points.size() == 1 ||
                   nums_edges_between_points.size() == points.size() - 1 + loop,
               "nums_edges_between_points must be either a single value or have the same number of "
               "entries as segments defined by the points.");
   mooseAssert(
       mid_points.size() == 0 || mid_points.size() == points.size() - (loop ? 0 : 1),
       "mid_points must be either empty or have the consistent number of entries as points.");
   mooseAssert(
       mid_points.size() == 0 ||
           (nums_edges_between_points.size() == 1 && nums_edges_between_points.front() == 1) ||
           (nums_edges_between_points.size() == points.size() - 1 + loop &&
            std::all_of(nums_edges_between_points.begin(),
                        nums_edges_between_points.end(),
                        [](unsigned int n) { return n == 1; })),
       "mid_points can only be provided if each segment has exactly one edge.");
 
   const auto n_points = points.size();
   for (auto i : make_range(n_points))
   {
     const auto & num_edges_between_points =
         (nums_edges_between_points.size() == 1)
             ? nums_edges_between_points[0]
             : (i == nums_edges_between_points.size() ? 0 : nums_edges_between_points[i]);
 
     Point p = points[i];
     const auto pt_counter = (nums_edges_between_points.size() == 1)
                                 ? i
                                 : std::accumulate(nums_edges_between_points.begin(),
                                                   nums_edges_between_points.begin() + i,
                                                   0);
     mesh.add_point(
         p, nums_edges_between_points.size() == 1 ? (i * num_edges_between_points) : pt_counter);
 
     if (num_edges_between_points > 1)
     {
       if (!loop && (i + 1) == n_points)
         break;
 
       const auto ip1 = (i + 1) % n_points;
       const Point pvec = (points[ip1] - p) / num_edges_between_points;
 
       for (auto j : make_range(1u, num_edges_between_points))
       {
         p += pvec;
         mesh.add_point(
             p,
             (nums_edges_between_points.size() == 1 ? (i * num_edges_between_points) : pt_counter) +
                 j);
       }
     }
   }
   // Add mid points if applicable. When mid points are provided, each segment has exactly one edge,
   // so the midpoint node ids follow the vertex node ids.
   for (const auto & i : make_range(mid_points.size()))
     mesh.add_point(mid_points[i], n_points + i);
 
   const auto n_segments = loop ? n_points : (n_points - 1);
   const auto n_elem =
       nums_edges_between_points.size() == 1
           ? n_segments * nums_edges_between_points[0]
           : std::accumulate(nums_edges_between_points.begin(), nums_edges_between_points.end(), 0);
   const auto max_nodes =
       (nums_edges_between_points.size() == 1 ? n_segments * nums_edges_between_points[0]
                                              : std::accumulate(nums_edges_between_points.begin(),
                                                                nums_edges_between_points.end(),
                                                                0)) +
       (loop ? 0 : 1);
   for (auto i : make_range(n_elem))
   {
     std::unique_ptr<Elem> elem;
     if (mid_points.size())
     {
       elem = std::make_unique<Edge3>();
       elem->set_node(2, mesh.node_ptr(n_points + i));
     }
     else
       elem = Elem::build(EDGE2);
     const auto ip1 = (i + 1) % max_nodes;
     elem->set_node(0, mesh.node_ptr(i));
     elem->set_node(1, mesh.node_ptr(ip1));
     elem->set_id() = i;
     mesh.add_elem(std::move(elem));
   }
 
   if (!loop)
   {
     BoundaryInfo & bi = mesh.get_boundary_info();
     std::vector<BoundaryName> bdy_names{start_boundary, end_boundary};
     std::vector<boundary_id_type> ids = MooseMeshUtils::getBoundaryIDs(mesh, bdy_names, true);
     bi.add_side(mesh.elem_ptr(0), 0, ids[0]);
     bi.add_side(mesh.elem_ptr(n_elem - 1), 1, ids[1]);
   }
   else
     mooseAssert(start_boundary.empty() && end_boundary.empty(),
                 "Cannot assign start/end boundaries on a looped polyline.");
 
   mesh.prepare_for_use();
 }

◆ buildPolyLineMesh() [5/6]

void MooseMeshUtils::buildPolyLineMesh	(	MeshBase &	mesh,
		const std::vector< Point > &	points,
		const bool	loop,
		const BoundaryName &	start_boundary,
		const BoundaryName &	end_boundary,
		const std::vector< unsigned int > &	nums_edges_between_points
	)

Definition at line 1519 of file MooseMeshUtils.C.

 {
   buildPolyLineMesh(
       mesh, points, {}, loop, start_boundary, end_boundary, nums_edges_between_points);
 }

◆ buildPolyLineMesh() [6/6]

void MooseMeshUtils::buildPolyLineMesh	(	MeshBase &	mesh,
		const std::vector< Point > &	points,
		const bool	loop,
		const BoundaryName &	start_boundary,
		const BoundaryName &	end_boundary,
		const Real	max_elem_size
	)

Definition at line 1531 of file MooseMeshUtils.C.

Referenced by buildPolyLineMesh().

 {
   std::vector<unsigned int> nums_edges_between_points;
   const auto n_points = points.size();
   for (auto i : make_range(n_points))
   {
     if (!loop && (i + 1) == n_points)
       break;
 
     const auto ip1 = (i + 1) % n_points;
     const Real length = (points[ip1] - points[i]).norm();
     const unsigned int n_elems = std::max(
         static_cast<unsigned int>(std::ceil(length / max_elem_size)), static_cast<unsigned int>(1));
     nums_edges_between_points.push_back(n_elems);
   }
 
   buildPolyLineMesh(
       mesh, points, {}, loop, start_boundary, end_boundary, nums_edges_between_points);
 }

◆ changeBoundaryId() [1/2]

void MooseMeshUtils::changeBoundaryId	(	MeshBase &	mesh,
		const libMesh::boundary_id_type	old_id,
		const libMesh::boundary_id_type	new_id,
		bool	delete_prev
	)

Changes the old boundary ID to a new ID in the mesh.

Parameters

mesh	the mesh
old_id	the old boundary id
new_id	the new boundary id
delete_prev	whether to delete the previous boundary id from the mesh

Referenced by MeshExtruderGenerator::changeID(), FillBetweenSidesetsGenerator::generate(), XYDelaunayGenerator::generate(), MooseMeshElementConversionUtils::transitionLayerGenerator(), and MeshTriangulationUtils::triangulateWithDelaunay().

◆ changeBoundaryId() [2/2]

void MooseMeshUtils::changeBoundaryId	(	MeshBase &	mesh,
		const boundary_id_type	old_id,
		const boundary_id_type	new_id,
		bool	delete_prev
	)

Definition at line 65 of file MooseMeshUtils.C.

 {
   // Get a reference to our BoundaryInfo object, we will use it several times below...
   BoundaryInfo & boundary_info = mesh.get_boundary_info();
 
   // Container to catch ids passed back from BoundaryInfo
   std::vector<boundary_id_type> old_ids;
 
   // Only level-0 elements store BCs.  Loop over them.
   for (auto & elem : as_range(mesh.level_elements_begin(0), mesh.level_elements_end(0)))
   {
     unsigned int n_sides = elem->n_sides();
     for (const auto s : make_range(n_sides))
     {
       boundary_info.boundary_ids(elem, s, old_ids);
       if (std::find(old_ids.begin(), old_ids.end(), old_id) != old_ids.end())
       {
         std::vector<boundary_id_type> new_ids(old_ids);
         std::replace(new_ids.begin(), new_ids.end(), old_id, new_id);
         if (delete_prev)
         {
           boundary_info.remove_side(elem, s);
           boundary_info.add_side(elem, s, new_ids);
         }
         else
           boundary_info.add_side(elem, s, new_ids);
       }
     }
   }
 
   // Remove any remaining references to the old ID from the
   // BoundaryInfo object.  This prevents things like empty sidesets
   // from showing up when printing information, etc.
   if (delete_prev)
     boundary_info.remove_id(old_id);
 
   // global information may now be out of sync
   mesh.unset_is_prepared();
 }

◆ changeSubdomainId() [1/2]

void MooseMeshUtils::changeSubdomainId	(	MeshBase &	mesh,
		const subdomain_id_type	old_id,
		const subdomain_id_type	new_id
	)

Changes the old subdomain ID to a new ID in the mesh.

Parameters

mesh	the mesh
old_id	the old subdomain id
new_id	the new subdomain id

◆ changeSubdomainId() [2/2]

void MooseMeshUtils::changeSubdomainId	(	MeshBase &	mesh,
		const subdomain_id_type	old_id,
		const subdomain_id_type	new_id
	)

Definition at line 269 of file MooseMeshUtils.C.

 {
   for (const auto & elem : mesh.element_ptr_range())
     if (elem->subdomain_id() == old_id)
       elem->subdomain_id() = new_id;
 
   // global cached information may now be out of sync
   mesh.unset_is_prepared();
 }

◆ computeDistanceToAxis()

template<typename P , typename C >

C MooseMeshUtils::computeDistanceToAxis	(	const P &	point,
		const Point &	origin,
		const RealVectorValue &	direction
	)

Computes the distance to a general axis.

Parameters

[in]	point	Point for which to compute distance from axis
[in]	origin	Axis starting point
[in]	direction	Axis direction

Definition at line 205 of file MooseMeshUtils.h.

 {
   return (point - origin).cross(direction).norm();
 }

◆ computeFiniteVolumeCoords()

void MooseMeshUtils::computeFiniteVolumeCoords	(	FaceInfo &	fi,
		const Moose::CoordinateSystemType	coord_type,
		const unsigned int	rz_radial_coord = `libMesh::invalid_uint`
	)

inline

Definition at line 239 of file MooseMeshUtils.h.

 {
   coordTransformFactor(fi.faceCentroid(), fi.faceCoord(), coord_type, rz_radial_coord);
 }

◆ computeMaxDistanceToAxis() [1/2]

Real MooseMeshUtils::computeMaxDistanceToAxis	(	const MeshBase &	mesh,
		const Point &	origin,
		const RealVectorValue &	direction
	)

Computes the maximum distance from all nodes of a mesh to a general axis.

Parameters

[in]	mesh	mesh to get the distance from
[in]	origin	Axis starting point
[in]	direction	Axis direction

Referenced by AdvancedExtruderGenerator::generate().

◆ computeMaxDistanceToAxis() [2/2]

Real MooseMeshUtils::computeMaxDistanceToAxis	(	const MeshBase &	mesh,
		const Point &	origin,
		const RealVectorValue &	direction
	)

Definition at line 363 of file MooseMeshUtils.C.

 {
   Real distance = 0;
   mooseAssert(MooseUtils::absoluteFuzzyEqual(direction.norm_sq(), 1),
               "Direction should be normalized");
   for (const auto & node : mesh.node_ptr_range())
     if (const auto dist_node = (*node - origin).cross(direction).norm(); dist_node > distance)
       distance = dist_node;
   mesh.comm().max(distance);
   return distance;
 }

◆ convertBlockToMesh() [1/2]

void MooseMeshUtils::convertBlockToMesh	(	MeshBase &	source_mesh,
		MeshBase &	target_mesh,
		const std::vector< SubdomainName > &	target_blocks
	)

Convert a list of blocks in a given mesh to a standalone new mesh.

Parameters

source_mesh	The source mesh from which the blocks will be converted
target_mesh	The target mesh to which the blocks will be converted
target_blocks	The names of the blocks to be converted to the target mesh

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), BlockToMeshConverterGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), Boundary2DDelaunayGenerator::generate(), and SurfaceSubdomainsDelaunayRemesher::generate().

◆ convertBlockToMesh() [2/2]

void MooseMeshUtils::convertBlockToMesh	(	MeshBase &	source_mesh,
		MeshBase &	target_mesh,
		const std::vector< SubdomainName > &	target_blocks
	)

Definition at line 1172 of file MooseMeshUtils.C.

 {
   if (!source_mesh.is_replicated())
     mooseError("This generator does not support distributed meshes.");
 
   const auto target_block_ids = MooseMeshUtils::getSubdomainIDs(source_mesh, target_blocks);
 
   // Check that the block ids/names exist in the mesh
   std::set<SubdomainID> mesh_blocks;
   source_mesh.subdomain_ids(mesh_blocks);
 
   for (const auto i : index_range(target_block_ids))
     if (target_block_ids[i] == Moose::INVALID_BLOCK_ID || !mesh_blocks.count(target_block_ids[i]))
     {
       mooseException("The target_block '", target_blocks[i], "' was not found within the mesh.");
     }
 
   // know which nodes have already been inserted, by tracking the old mesh's node's ids'
   std::unordered_map<dof_id_type, dof_id_type> old_new_node_map;
 
   for (const auto target_block_id : target_block_ids)
   {
 
     for (auto elem : source_mesh.active_subdomain_elements_ptr_range(target_block_id))
     {
       if (elem->level() != 0)
         mooseError("Refined blocks are not supported by this generator. "
                    "Can you re-organize mesh generators to refine after converting the block?");
 
       // make a deep copy so that mutiple meshes' destructors don't segfault at program termination
       auto copy = elem->build(elem->type());
 
       // Keep the subdomain id
       copy->subdomain_id() = elem->subdomain_id();
 
       // index of node in the copy element must be managed manually as there is no intelligent
       // insert method
       dof_id_type copy_n_index = 0;
 
       // correctly assign new copies of nodes, loop over nodes
       for (dof_id_type i : elem->node_index_range())
       {
         auto & n = elem->node_ref(i);
 
         if (old_new_node_map.count(n.id()))
         {
           // case where we have already inserted this particular point before
           // then we need to find the already-inserted one and hook it up right
           // to it's respective element
           copy->set_node(copy_n_index++, target_mesh.node_ptr(old_new_node_map[n.id()]));
         }
         else
         {
           // case where we've NEVER inserted this particular point before
           // add them both to the element and the mesh
 
           // Nodes' IDs are their indexes in the nodes' respective mesh
           // If we set them as invalid they are automatically assigned
           // Add to mesh, auto-assigning a new id.
           Node * node = target_mesh.add_point(elem->point(i));
 
           // Add to element copy (manually)
           copy->set_node(copy_n_index++, node);
 
           // remember the (old) ID
           old_new_node_map[n.id()] = node->id();
         }
       }
 
       // it is ok to release the copy element into the mesh because derived meshes class
       // (ReplicatedMesh, DistributedMesh) manage their own elements, will delete them
       target_mesh.add_elem(copy.release());
     }
   }
 
   // Move subdomain names
   for (const auto sbd_id : target_block_ids)
     target_mesh.subdomain_name(sbd_id) = source_mesh.subdomain_name(sbd_id);
 }

◆ coordTransformFactor()

template<typename P , typename C >

void MooseMeshUtils::coordTransformFactor	(	const P &	point,
		C &	factor,
		const Moose::CoordinateSystemType	coord_type,
		const unsigned int	rz_radial_coord = `libMesh::invalid_uint`
	)

Compute a coordinate transformation volume integration factor.

Parameters

point	The libMesh `Point` in space where we are evaluating the factor
factor	The output of this function. Would be 1 for cartesian coordinate systems, 2pir for cylindrical coordinate systems, and 4pir^2 for spherical coordinate systems
coord_type	The coordinate system type, e.g. cartesian (COORD_XYZ), cylindrical (COORD_RZ), or spherical (COORD_RSPHERICAL)
rz_radial_coord	The index at which to index `point` for the radial coordinate when in a cylindrical coordinate system

Definition at line 171 of file MooseMeshUtils.h.

Referenced by computeFiniteVolumeCoords(), coordTransformFactor(), Moose::FV::greenGaussGradient(), and Moose::FV::loopOverElemFaceInfo().

 {
   switch (coord_type)
   {
     case Moose::COORD_XYZ:
       factor = 1.0;
       break;
     case Moose::COORD_RZ:
     {
       mooseAssert(rz_radial_coord != libMesh::invalid_uint,
                   "Must pass in a valid rz radial coordinate");
       factor = 2 * M_PI * point(rz_radial_coord);
       break;
     }
     case Moose::COORD_RSPHERICAL:
       factor = 4 * M_PI * point(0) * point(0);
       break;
     default:
       mooseError("Unknown coordinate system");
   }
 }

◆ coordTransformFactorRZGeneral()

template<typename P , typename C >

void MooseMeshUtils::coordTransformFactorRZGeneral	(	const P &	point,
		const std::pair< Point, RealVectorValue > &	axis,
		C &	factor
	)

Computes a coordinate transformation factor for a general axisymmetric axis.

Parameters

[in]	point	The libMesh `Point` in space where we are evaluating the factor
[in]	axis	The pair of values defining the general axisymmetric axis. Respectively, the values are the axis starting point and direction.
[out]	factor	The coordinate transformation factor

Definition at line 231 of file MooseMeshUtils.h.

Referenced by coordTransformFactor().

 {
   factor = 2 * M_PI * computeDistanceToAxis<P, C>(point, axis.first, axis.second);
 }

◆ copyIntoMesh() [1/2]

void MooseMeshUtils::copyIntoMesh	(	MeshGenerator &	mg,
		UnstructuredMesh &	destination,
		const UnstructuredMesh &	source,
		const bool	avoid_merging_subdomains,
		const bool	avoid_merging_boundaries,
		const Parallel::Communicator &	communicator
	)

Helper function for copying one mesh into another.

Parameters

mg	The mesh generator calling this function
destination	The mesh to copy into
source	The mesh to copy from
avoid_merging_subdomains	If true, subdomain IDs in the source mesh will be offset to avoid merging with subdomain IDs in the destination mesh
avoid_merging_boundaries	If true, boundary IDs in the source mesh will be offset to avoid merging with boundary IDs in the destination mesh
communicator	The communicator for parallel operations

Referenced by CombinerGenerator::generate(), and XYZDelaunayGenerator::generate().

◆ copyIntoMesh() [2/2]

void MooseMeshUtils::copyIntoMesh	(	MeshGenerator &	mg,
		UnstructuredMesh &	destination,
		const UnstructuredMesh &	source,
		const bool	avoid_merging_subdomains,
		const bool	avoid_merging_boundaries,
		const Parallel::Communicator &	communicator
	)

Definition at line 1255 of file MooseMeshUtils.C.

 {
   dof_id_type node_delta = destination.max_node_id();
   dof_id_type elem_delta = destination.max_elem_id();
 
   unique_id_type unique_delta =
 #ifdef LIBMESH_ENABLE_UNIQUE_ID
       destination.parallel_max_unique_id();
 #else
       0;
 #endif
 
   // Prevent overlaps by offsetting the subdomains in
   std::unordered_map<subdomain_id_type, subdomain_id_type> id_remapping;
   unsigned int block_offset = 0;
   if (avoid_merging_subdomains)
   {
     // Note: if performance becomes an issue, this is overkill for just getting the max node id
     std::set<subdomain_id_type> source_ids;
     std::set<subdomain_id_type> dest_ids;
 
     // We need source subdomain ids already cached; libMesh will
     // scream otherwise
     source.subdomain_ids(source_ids, true);
 
     // Our destination is non-const, so we can fix any missing caches
     if (!destination.preparation().has_cached_elem_data)
       destination.cache_elem_data();
 
     destination.subdomain_ids(dest_ids, true);
 
     mooseAssert(source_ids.size(), "Should have a subdomain");
     mooseAssert(dest_ids.size(), "Should have a subdomain");
     unsigned int max_dest_bid = *dest_ids.rbegin();
     unsigned int min_source_bid = *source_ids.begin();
     communicator.max(max_dest_bid);
     communicator.min(min_source_bid);
     block_offset = 1 + max_dest_bid - min_source_bid;
     for (const auto bid : source_ids)
       id_remapping[bid] = block_offset + bid;
   }
 
   // Copy mesh data over from the other mesh
   destination.copy_nodes_and_elements(source,
                                       // Skipping this should cause the neighbors
                                       // to simply be copied from the other mesh
                                       // (which makes sense and is way faster)
                                       /*skip_find_neighbors = */ true,
                                       elem_delta,
                                       node_delta,
                                       unique_delta,
                                       avoid_merging_subdomains ? &id_remapping : nullptr);
 
   // Get an offset to prevent overlaps / wild merging between boundaries
   BoundaryInfo & boundary = destination.get_boundary_info();
   const BoundaryInfo & other_boundary = source.get_boundary_info();
 
   unsigned int bid_offset = 0;
   if (avoid_merging_boundaries)
   {
     const auto boundary_ids = boundary.get_boundary_ids();
     const auto other_boundary_ids = other_boundary.get_boundary_ids();
     unsigned int max_dest_bid = boundary_ids.size() ? *boundary_ids.rbegin() : 0;
     unsigned int min_source_bid = other_boundary_ids.size() ? *other_boundary_ids.begin() : 0;
     communicator.max(max_dest_bid);
     communicator.min(min_source_bid);
     bid_offset = 1 + max_dest_bid - min_source_bid;
   }
 
   // Note: the code below originally came from ReplicatedMesh::stitch_mesh_helper()
   // in libMesh replicated_mesh.C around line 1203
 
   // Copy BoundaryInfo from other_mesh too.  We do this via the
   // list APIs rather than element-by-element for speed.
   for (const auto & t : other_boundary.build_node_list())
     boundary.add_node(std::get<0>(t) + node_delta, bid_offset + std::get<1>(t));
 
   for (const auto & t : other_boundary.build_side_list())
     boundary.add_side(std::get<0>(t) + elem_delta, std::get<1>(t), bid_offset + std::get<2>(t));
 
   for (const auto & t : other_boundary.build_edge_list())
     boundary.add_edge(std::get<0>(t) + elem_delta, std::get<1>(t), bid_offset + std::get<2>(t));
 
   for (const auto & t : other_boundary.build_shellface_list())
     boundary.add_shellface(
         std::get<0>(t) + elem_delta, std::get<1>(t), bid_offset + std::get<2>(t));
 
   // Check for the case with two block ids sharing the same name
   if (avoid_merging_subdomains)
   {
     mooseAssert(mg.parameters().isParamDefined("avoid_merging_subdomains"),
                 "Missing parameter in the mesh generator calling this function: "
                 "avoid_merging_subdomains. Considering setting avoid_merging_subdomains to true.");
     for (const auto & [block_id, block_name] : destination.get_subdomain_name_map())
       for (const auto & [source_id, source_name] : source.get_subdomain_name_map())
         if (block_name == source_name)
           mg.paramWarning(
               "avoid_merging_subdomains",
               "Not merging subdomains is creating two subdomains with the same name '" +
                   block_name + "' but different ids: " + std::to_string(source_id) + " & " +
                   std::to_string(block_id + block_offset) +
                   ".\n We recommend using a RenameBlockGenerator to prevent this as you "
                   "will get errors reading the Exodus output later.");
   }
 
   for (const auto & [block_id, block_name] : source.get_subdomain_name_map())
     destination.set_subdomain_name_map().insert(
         std::make_pair<SubdomainID, SubdomainName>(block_id + block_offset, block_name));
 
   // Check for the case with two boundary ids sharing the same name
   if (avoid_merging_boundaries)
   {
     mooseAssert(mg.parameters().isParamDefined("avoid_merging_boundaries"),
                 "Missing parameter in the mesh generator calling this function: "
                 "avoid_merging_boundaries. Considering setting avoid_merging_boundaries to true.");
     for (const auto & [b_id, b_name] : other_boundary.get_sideset_name_map())
       for (const auto & [source_id, source_name] : boundary.get_sideset_name_map())
         if (b_name == source_name)
           mg.paramWarning(
               "avoid_merging_boundaries",
               "Not merging boundaries is creating two sidesets with the same name '" + b_name +
                   "' but different ids: " + std::to_string(source_id) + " & " +
                   std::to_string(b_id + bid_offset) +
                   ".\n We recommend using a RenameBoundaryGenerator to prevent this as you "
                   "will get errors reading the Exodus output later.");
     for (const auto & [b_id, b_name] : other_boundary.get_nodeset_name_map())
       for (const auto & [source_id, source_name] : boundary.get_nodeset_name_map())
         if (b_name == source_name)
           mg.paramWarning(
               "avoid_merging_boundaries",
               "Not merging boundaries is creating two nodesets with the same name '" + b_name +
                   "' but different ids: " + std::to_string(source_id) + " & " +
                   std::to_string(b_id + bid_offset) +
                   ".\n We recommend using a RenameBoundaryGenerator to prevent this as you "
                   "will get errors reading the Exodus output later.");
   }
 
   for (const auto & [nodeset_id, nodeset_name] : other_boundary.get_nodeset_name_map())
     boundary.set_nodeset_name_map().insert(
         std::make_pair<BoundaryID, BoundaryName>(nodeset_id + bid_offset, nodeset_name));
 
   for (const auto & [sideset_id, sideset_name] : other_boundary.get_sideset_name_map())
     boundary.set_sideset_name_map().insert(
         std::make_pair<BoundaryID, BoundaryName>(sideset_id + bid_offset, sideset_name));
 
   for (const auto & [edgeset_id, edgeset_name] : other_boundary.get_edgeset_name_map())
     boundary.set_edgeset_name_map().insert(
         std::make_pair<BoundaryID, BoundaryName>(edgeset_id + bid_offset, edgeset_name));
 }

◆ createSubdomainFromSidesets() [1/2]

void MooseMeshUtils::createSubdomainFromSidesets	(	MeshBase &	mesh,
		std::vector< BoundaryName >	boundary_names,
		const SubdomainID	new_subdomain_id,
		const SubdomainName	new_subdomain_name,
		const std::string	type_name
	)

Create a new subdomain by generating new side elements from a list of sidesets in a given mesh.

Parameters

mesh	The mesh to work on
boundary_names	The names of the sidesets to be used to create the new subdomain
new_subdomain_id	The ID of the new subdomain to be created based on the sidesets
new_subdomain_name	The name of the new subdomain to be created based on the sidesets
type_name	The type of the mesh generator that is calling this method, used for error messages and debugging purposes.

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), LowerDBlockFromSidesetGenerator::generate(), and Boundary2DDelaunayGenerator::generate().

◆ createSubdomainFromSidesets() [2/2]

void MooseMeshUtils::createSubdomainFromSidesets	(	MeshBase &	mesh,
		std::vector< BoundaryName >	boundary_names,
		const SubdomainID	new_subdomain_id,
		const SubdomainName	new_subdomain_name,
		const std::string	type_name
	)

Definition at line 1026 of file MooseMeshUtils.C.

 {
   // Generate a new block id if one isn't supplied.
   SubdomainID new_block_id = new_subdomain_id;
 
   // Make sure our boundary info and parallel counts are setup
   if (!mesh.is_prepared())
   {
     const bool allow_remote_element_removal = mesh.allow_remote_element_removal();
     // We want all of our boundary elements available, so avoid removing them if they haven't
     // already been so
     mesh.allow_remote_element_removal(false);
     mesh.prepare_for_use();
     mesh.allow_remote_element_removal(allow_remote_element_removal);
   }
 
   // Check that the sidesets are present in the mesh
   for (const auto & sideset : boundary_names)
     if (!MooseMeshUtils::hasBoundaryNameOrID(mesh, sideset))
       mooseException("The sideset '", sideset, "' was not found within the mesh");
 
   auto sideset_ids = MooseMeshUtils::getBoundaryIDs(mesh, boundary_names, true);
   std::set<boundary_id_type> sidesets(sideset_ids.begin(), sideset_ids.end());
   auto side_list = mesh.get_boundary_info().build_side_list();
   if (!mesh.is_serial() && mesh.comm().size() > 1)
   {
     std::vector<Elem *> elements_to_send;
     unsigned short i_need_boundary_elems = 0;
     for (const auto & [elem_id, side, bc_id] : side_list)
     {
       libmesh_ignore(side);
       if (sidesets.count(bc_id))
       {
         // Whether we have this boundary information through our locally owned element or a ghosted
         // element, we'll need the boundary elements for parallel consistent addition
         i_need_boundary_elems = 1;
         auto * elem = mesh.elem_ptr(elem_id);
         if (elem->processor_id() == mesh.processor_id())
           elements_to_send.push_back(elem);
       }
     }
 
     std::set<const Elem *, libMesh::CompareElemIdsByLevel> connected_elements(
         elements_to_send.begin(), elements_to_send.end());
     std::set<const Node *> connected_nodes;
     reconnect_nodes(connected_elements, connected_nodes);
     std::set<dof_id_type> connected_node_ids;
     for (auto * nd : connected_nodes)
       connected_node_ids.insert(nd->id());
 
     std::vector<unsigned short> need_boundary_elems(mesh.comm().size());
     mesh.comm().allgather(i_need_boundary_elems, need_boundary_elems);
     std::unordered_map<processor_id_type, decltype(elements_to_send)> push_element_data;
     std::unordered_map<processor_id_type, decltype(connected_nodes)> push_node_data;
 
     for (const auto pid : index_range(mesh.comm()))
       // Don't need to send to self
       if (pid != mesh.processor_id() && need_boundary_elems[pid])
       {
         if (elements_to_send.size())
           push_element_data[pid] = elements_to_send;
         if (connected_nodes.size())
           push_node_data[pid] = connected_nodes;
       }
 
     auto node_action_functor = [](processor_id_type, const auto &)
     {
       // Node packing specialization already has unpacked node into mesh, so nothing to do
     };
     Parallel::push_parallel_packed_range(mesh.comm(), push_node_data, &mesh, node_action_functor);
     auto elem_action_functor = [](processor_id_type, const auto &)
     {
       // Elem packing specialization already has unpacked elem into mesh, so nothing to do
     };
     TIMPI::push_parallel_packed_range(mesh.comm(), push_element_data, &mesh, elem_action_functor);
 
     // now that we've gathered everything, we need to rebuild the side list
     side_list = mesh.get_boundary_info().build_side_list();
   }
 
   std::vector<std::pair<dof_id_type, ElemSidePair>> element_sides_on_boundary;
   dof_id_type counter = 0;
   for (const auto & [eid, side, bid] : side_list)
     if (sidesets.count(bid))
     {
       if (auto elem = mesh.query_elem_ptr(eid))
       {
         if (!elem->active())
           mooseError(
               "Only active, level 0 elements can be made interior parents of new level 0 lower-d "
               "elements. Make sure that ",
               type_name,
               "s are run before any refinement generators");
         element_sides_on_boundary.push_back(std::make_pair(counter, ElemSidePair(elem, side)));
       }
       ++counter;
     }
 
   dof_id_type max_elem_id = mesh.max_elem_id();
   unique_id_type max_unique_id = mesh.parallel_max_unique_id();
 
   // Making an important assumption that at least our boundary elements are the same on all
   // processes even in distributed mesh mode (this is reliant on the correct ghosting functors
   // existing on the mesh)
   for (auto & [i, elem_side] : element_sides_on_boundary)
   {
     Elem * elem = elem_side.elem;
 
     const auto side = elem_side.side;
 
     // Build a non-proxy element from this side.
     std::unique_ptr<Elem> side_elem(elem->build_side_ptr(side));
 
     // The side will be added with the same processor id as the parent.
     side_elem->processor_id() = elem->processor_id();
 
     // Add subdomain ID
     side_elem->subdomain_id() = new_block_id;
 
     // Also assign the side's interior parent, so it is always
     // easy to figure out the Elem we came from.
     side_elem->set_interior_parent(elem);
 
     // Add id
     side_elem->set_id(max_elem_id + i);
     side_elem->set_unique_id(max_unique_id + i);
 
     // Finally, add the lower-dimensional element to the mesh.
     mesh.add_elem(side_elem.release());
   };
 
   // Assign block name, if provided
   if (new_subdomain_name.size())
     mesh.subdomain_name(new_block_id) = new_subdomain_name;
 
   const bool skip_partitioning_old = mesh.skip_partitioning();
   mesh.skip_partitioning(true);
   mesh.prepare_for_use();
   mesh.skip_partitioning(skip_partitioning_old);
 }

◆ extraElemIntegerSwapParametersProcessor()

void MooseMeshUtils::extraElemIntegerSwapParametersProcessor	(	const std::string &	class_name,
		const unsigned int	num_sections,
		const unsigned int	num_integers,
		const std::vector< std::vector< std::vector< dof_id_type >>> &	elem_integers_swaps,
		std::vector< std::unordered_map< dof_id_type, dof_id_type >> &	elem_integers_swap_pairs
	)

Reprocess the elem_integers_swaps into maps so they are easier to use.

Parameters

class_name	name of the mesh generator class used for exception messages
num_sections	number of sections in the mesh
num_integers	number of extra element integers in the mesh
elem_integers_swaps	vector of vectors of vectors of extra element ids to be swapped
elem_integers_swap_pairs	vector of maps of the swapped pairs

Definition at line 673 of file MooseMeshUtils.C.

Referenced by AdvancedExtruderGenerator::AdvancedExtruderGenerator().

 {
   elem_integers_swap_pairs.reserve(num_sections * num_integers);
   for (const auto i : make_range(num_integers))
   {
     const auto & elem_integer_swaps = elem_integers_swaps[i];
     std::vector<std::unordered_map<dof_id_type, dof_id_type>> elem_integer_swap_pairs;
     try
     {
       MooseMeshUtils::idSwapParametersProcessor(class_name,
                                                 "elem_integers_swaps",
                                                 elem_integer_swaps,
                                                 elem_integer_swap_pairs,
                                                 i * num_sections);
     }
     catch (const MooseException & e)
     {
       throw MooseException(e.what());
     }
 
     elem_integers_swap_pairs.insert(elem_integers_swap_pairs.end(),
                                     elem_integer_swap_pairs.begin(),
                                     elem_integer_swap_pairs.end());
   }
 }

◆ getBoundaryID() [1/2]

BoundaryID MooseMeshUtils::getBoundaryID	(	const BoundaryName &	boundary_name,
		const MeshBase &	mesh
	)

Gets the boundary ID associated with the given BoundaryName.

This is needed because the BoundaryName can be either an ID or a name. If it is a name, the mesh is queried for the ID associated with said name.

Referenced by MultiAppNearestNodeTransfer::execute(), BoundaryDeletionGenerator::generate(), RenameBoundaryGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), MooseMesh::getBoundaryID(), Moose::PeriodicBCHelper::setupManualPeriodicBoundaries(), MooseMeshElementConversionUtils::transitionLayerGenerator(), and MeshTriangulationUtils::triangulateWithDelaunay().

◆ getBoundaryID() [2/2]

BoundaryID MooseMeshUtils::getBoundaryID	(	const BoundaryName &	boundary_name,
		const MeshBase &	mesh
	)

Definition at line 236 of file MooseMeshUtils.C.

Referenced by hasBoundaryNameOrID().

 {
   BoundaryID id = Moose::INVALID_BOUNDARY_ID;
   if (boundary_name.empty())
     return id;
 
   if (!MooseUtils::isDigits(boundary_name))
     id = mesh.get_boundary_info().get_id_by_name(boundary_name);
   else
     id = getIDFromName<BoundaryName, BoundaryID>(boundary_name);
 
   return id;
 }

◆ getBoundaryIDs() [1/2]

std::vector< boundary_id_type > MooseMeshUtils::getBoundaryIDs	(	const libMesh::MeshBase &	mesh,
		const std::vector< BoundaryName > &	boundary_name,
		bool	generate_unknown,
		const std::set< BoundaryID > &	mesh_boundary_ids
	)

Gets the boundary IDs with their names.

The ordering of the returned boundary ID vector matches the vector of the boundary names in boundary_name. When a boundary name is not available in the mesh, if generate_unknown is true a non-existant boundary ID will be returned, otherwise a BoundaryInfo::invalid_id will be returned.

If the conversion from a name to a number fails, that means that this must be a named boundary. We will look in the complete map for this sideset and create a new name/ID pair if requested.

Definition at line 118 of file MooseMeshUtils.C.

 {
   const BoundaryInfo & boundary_info = mesh.get_boundary_info();
   const std::map<BoundaryID, std::string> & sideset_map = boundary_info.get_sideset_name_map();
   const std::map<BoundaryID, std::string> & nodeset_map = boundary_info.get_nodeset_name_map();
 
   BoundaryID max_boundary_local_id = 0;
   /* It is required to generate a new ID for a given name. It is used often in mesh modifiers such
    * as SideSetsBetweenSubdomains. Then we need to check the current boundary ids since they are
    * changing during "mesh modify()", and figure out the right max boundary ID. Most of mesh
    * modifiers are running in serial, and we won't involve a global communication.
    */
   if (generate_unknown)
   {
     const auto & bids = mesh.is_prepared() ? mesh.get_boundary_info().get_global_boundary_ids()
                                            : mesh.get_boundary_info().get_boundary_ids();
     max_boundary_local_id = bids.empty() ? 0 : *(bids.rbegin());
     /* We should not hit this often */
     if (!mesh.is_prepared() && !mesh.is_serial())
       mesh.comm().max(max_boundary_local_id);
   }
 
   BoundaryID max_boundary_id = mesh_boundary_ids.empty() ? 0 : *(mesh_boundary_ids.rbegin());
 
   max_boundary_id =
       max_boundary_id > max_boundary_local_id ? max_boundary_id : max_boundary_local_id;
 
   std::vector<BoundaryID> ids(boundary_name.size());
   for (const auto i : index_range(boundary_name))
   {
     if (boundary_name[i] == "ANY_BOUNDARY_ID")
     {
       ids.assign(mesh_boundary_ids.begin(), mesh_boundary_ids.end());
       if (i)
         mooseWarning("You passed \"ANY_BOUNDARY_ID\" in addition to other boundary_names.  This "
                      "may be a logic error.");
       break;
     }
 
     if (boundary_name[i].empty() && !generate_unknown)
       mooseError("Incoming boundary name is empty and we are not generating unknown boundary IDs. "
                  "This is invalid.");
 
     BoundaryID id;
 
     if (boundary_name[i].empty() || !MooseUtils::isDigits(boundary_name[i]))
     {
       if (generate_unknown &&
           !MooseUtils::doesMapContainValue(sideset_map, std::string(boundary_name[i])) &&
           !MooseUtils::doesMapContainValue(nodeset_map, std::string(boundary_name[i])))
         id = ++max_boundary_id;
       else
         id = boundary_info.get_id_by_name(boundary_name[i]);
     }
     else
       id = getIDFromName<BoundaryName, BoundaryID>(boundary_name[i]);
 
     ids[i] = id;
   }
 
   return ids;
 }

◆ getBoundaryIDs() [2/2]

std::vector< boundary_id_type > MooseMeshUtils::getBoundaryIDs	(	const libMesh::MeshBase &	mesh,
		const std::vector< BoundaryName > &	boundary_name,
		bool	generate_unknown
	)

Gets the boundary IDs with their names.

The ordering of the returned boundary ID vector matches the vector of the boundary names in boundary_name. When a boundary name is not available in the mesh, if generate_unknown is true a non-existant boundary ID will be returned, otherwise a BoundaryInfo::invalid_id will be returned.

Definition at line 109 of file MooseMeshUtils.C.

 {
   return getBoundaryIDs(
       mesh, boundary_name, generate_unknown, mesh.get_boundary_info().get_boundary_ids());
 }

◆ getBoundaryIDSet()

std::set< BoundaryID > MooseMeshUtils::getBoundaryIDSet	(	const libMesh::MeshBase &	mesh,
		const std::vector< BoundaryName > &	boundary_name,
		bool	generate_unknown
	)

Gets the boundary IDs into a set with their names.

Because libMesh allows the same boundary to have multiple different boundary names, the size of the returned boundary ID set may be smaller than the size of the boundary name vector. When a boundary name is not available in the mesh, if generate_unknown is true a non-existant boundary ID will be returned, otherwise a BoundaryInfo::invalid_id will be returned.

Definition at line 190 of file MooseMeshUtils.C.

Referenced by DomainUserObject::DomainUserObject().

 {
   auto boundaries = getBoundaryIDs(mesh, boundary_name, generate_unknown);
   return std::set<BoundaryID>(boundaries.begin(), boundaries.end());
 }

◆ getBoundaryNodes() [1/2]

std::set<dof_id_type> MooseMeshUtils::getBoundaryNodes	(	const MeshBase &	mesh,
		const BoundaryID	boundary_id
	)

Get all the nodes on that particular boundary, whether a nodeset or a sideset.

Note: if the mesh has both a nodeset and a sideset with the same ID, they will both be considered If this is undesirable, renumber one of them prior to calling this routine

Parameters

input_mesh	The input mesh to get the map for
boundary_id	The boundary id of interest

◆ getBoundaryNodes() [2/2]

std::set<dof_id_type> MooseMeshUtils::getBoundaryNodes	(	const MeshBase &	mesh,
		const BoundaryID	boundary_id
	)

Definition at line 998 of file MooseMeshUtils.C.

Referenced by buildBoundaryNodeToElemMap().

 {
   std::set<dof_id_type> boundary_node_ids;
   const BoundaryInfo & boundary_info = mesh.get_boundary_info();
 
   // Get all nodes from the sideset with ID of boundary_id
   const auto & bc_sides =
       boundary_info.build_side_list(libMesh::BoundaryInfo::BCTupleSortBy::BOUNDARY_ID);
   for (const auto & [elem_id, side, bc_id] : bc_sides)
   {
     if (bc_id == boundary_id)
     {
       const auto elem = mesh.elem_ptr(elem_id);
       for (const auto ni : elem->nodes_on_side(side))
         boundary_node_ids.insert(elem->node_id(ni));
     }
   }
 
   // Get all nodes from nodeset with ID of boundary_id
   const auto & bc_nodes = boundary_info.build_node_list();
   for (const auto & [n_id, bc_id] : bc_nodes)
     if (bc_id == boundary_id)
       boundary_node_ids.insert(n_id);
 
   return boundary_node_ids;
 }

◆ getExtraIDUniqueCombinationMap() [1/2]

std::unordered_map<dof_id_type, dof_id_type> MooseMeshUtils::getExtraIDUniqueCombinationMap	(	const MeshBase &	mesh,
		const std::set< SubdomainID > &	block_ids,
		std::vector< ExtraElementIDName >	extra_ids
	)

Create a new set of element-wise IDs by finding unique combinations of existing extra ID values.

This function finds the unique combinations by recursively calling itself for extra ID inputs. In the recursive calling, the new unique combinations is determined by combining the extra ID value of current level and the unique combination determined in the previous level in recursion. In the lowest level of recursion, the base combination is set by the unique ID values of the corresponding extra ID.

Parameters

mesh	input mesh
block_ids	block ids
extra_ids	extra ids

Returns: map of element id to new extra id

Referenced by ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), UniqueExtraIDMeshGenerator::generate(), and getExtraIDUniqueCombinationMap().

◆ getExtraIDUniqueCombinationMap() [2/2]

std::unordered_map<dof_id_type, dof_id_type> MooseMeshUtils::getExtraIDUniqueCombinationMap	(	const MeshBase &	mesh,
		const std::set< SubdomainID > &	block_ids,
		std::vector< ExtraElementIDName >	extra_ids
	)

Definition at line 378 of file MooseMeshUtils.C.

 {
   // check block restriction
   const bool block_restricted = !block_ids.empty();
   // get element id name of interest in recursive parsing algorithm
   ExtraElementIDName id_name = extra_ids.back();
   extra_ids.pop_back();
   const auto id_index = mesh.get_elem_integer_index(id_name);
 
   // create base parsed id set
   if (extra_ids.empty())
   {
     // get set of extra id values;
     std::vector<dof_id_type> ids;
     {
       std::set<dof_id_type> ids_set;
       for (const auto & elem : mesh.active_element_ptr_range())
       {
         if (block_restricted && block_ids.find(elem->subdomain_id()) == block_ids.end())
           continue;
         const auto id = elem->get_extra_integer(id_index);
         ids_set.insert(id);
       }
       mesh.comm().set_union(ids_set);
       ids.assign(ids_set.begin(), ids_set.end());
     }
 
     // determine new extra id values;
     std::unordered_map<dof_id_type, dof_id_type> parsed_ids;
     for (auto & elem : mesh.active_element_ptr_range())
     {
       if (block_restricted && block_ids.find(elem->subdomain_id()) == block_ids.end())
         continue;
       parsed_ids[elem->id()] = std::distance(
           ids.begin(), std::lower_bound(ids.begin(), ids.end(), elem->get_extra_integer(id_index)));
     }
     return parsed_ids;
   }
 
   // if extra_ids is not empty, recursively call getExtraIDUniqueCombinationMap
   const auto base_parsed_ids =
       MooseMeshUtils::getExtraIDUniqueCombinationMap(mesh, block_ids, extra_ids);
   // parsing extra ids based on ref_parsed_ids
   std::vector<std::pair<dof_id_type, dof_id_type>> unique_ids;
   {
     std::set<std::pair<dof_id_type, dof_id_type>> unique_ids_set;
     for (const auto & elem : mesh.active_element_ptr_range())
     {
       if (block_restricted && block_ids.find(elem->subdomain_id()) == block_ids.end())
         continue;
       const dof_id_type id1 = libmesh_map_find(base_parsed_ids, elem->id());
       const dof_id_type id2 = elem->get_extra_integer(id_index);
       const std::pair<dof_id_type, dof_id_type> ids = std::make_pair(id1, id2);
       unique_ids_set.insert(ids);
     }
     mesh.comm().set_union(unique_ids_set);
     unique_ids.assign(unique_ids_set.begin(), unique_ids_set.end());
   }
 
   std::unordered_map<dof_id_type, dof_id_type> parsed_ids;
 
   for (const auto & elem : mesh.active_element_ptr_range())
   {
     if (block_restricted && block_ids.find(elem->subdomain_id()) == block_ids.end())
       continue;
     const dof_id_type id1 = libmesh_map_find(base_parsed_ids, elem->id());
     const dof_id_type id2 = elem->get_extra_integer(id_index);
     const dof_id_type new_id = std::distance(
         unique_ids.begin(),
         std::lower_bound(unique_ids.begin(), unique_ids.end(), std::make_pair(id1, id2)));
     parsed_ids[elem->id()] = new_id;
   }
 
   return parsed_ids;
 }

◆ getIDFromName()

template<typename T , typename Q >

Q MooseMeshUtils::getIDFromName ( const T & name )

Converts a given name (BoundaryName or SubdomainName) that is known to only contain digits into a corresponding ID (BoundaryID or SubdomainID) and performs bounds checking to ensure that overflow doesn't happen.

Parameters

name	Name that is to be converted into an ID.

Returns: ID type corresponding to the type of name.

Definition at line 383 of file MooseMeshUtils.h.

 {
   if (!MooseUtils::isDigits(name))
     mooseError(
         "'name' ", name, " should only contain digits that can be converted to a numerical type.");
   long long id = std::stoll(name);
   Q id_Q = Q(id);
   if (id < std::numeric_limits<Q>::min() || id > std::numeric_limits<Q>::max())
     mooseError(MooseUtils::prettyCppType<T>(&name),
                " ",
                name,
                " is not within the numeric limits of the expected ID type ",
                MooseUtils::prettyCppType<Q>(&id_Q),
                ".");
 
   return id_Q;
 }

◆ getNextFreeBoundaryID() [1/2]

BoundaryID MooseMeshUtils::getNextFreeBoundaryID ( MeshBase & input_mesh )

Checks input mesh and returns the largest boundary ID in the mesh plus one, which is a boundary ID in the mesh that is not currently in use.

Parameters

input mesh over which to compute the next free boundary ID

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), XYZDelaunayGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), XYDelaunayGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), XYMeshLineCutter::generate(), SurfaceSubdomainsDelaunayRemesher::generate(), MooseMeshElementConversionUtils::transitionLayerGenerator(), and MeshTriangulationUtils::triangulateWithDelaunay().

◆ getNextFreeBoundaryID() [2/2]

BoundaryID MooseMeshUtils::getNextFreeBoundaryID ( MeshBase & input_mesh )

Definition at line 519 of file MooseMeshUtils.C.

 {
   if (!input_mesh.preparation().has_boundary_id_sets)
     input_mesh.get_boundary_info().regenerate_id_sets();
 
   auto boundary_ids = input_mesh.get_boundary_info().get_boundary_ids();
   if (boundary_ids.empty())
     return 0;
   return (*boundary_ids.rbegin() + 1);
 }

◆ getNextFreeSubdomainID() [1/2]

SubdomainID MooseMeshUtils::getNextFreeSubdomainID ( MeshBase & input_mesh )

Checks input mesh and returns max(block ID) + 1, which represents a block ID that is not currently in use in the mesh.

Parameters

input mesh over which to compute the next free block id

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), LowerDBlockFromSidesetGenerator::generate(), BoundaryLayerSubdomainGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), XYZDelaunayGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), Boundary2DDelaunayGenerator::generate(), MeshRepairGenerator::separateSubdomainsByElementType(), MooseMeshElementConversionUtils::transitionLayerGenerator(), and MeshTriangulationUtils::triangulateWithDelaunay().

◆ getNextFreeSubdomainID() [2/2]

SubdomainID MooseMeshUtils::getNextFreeSubdomainID ( MeshBase & input_mesh )

Definition at line 499 of file MooseMeshUtils.C.

 {
   // Call this to get most up to date block id information
   input_mesh.cache_elem_data();
 
   std::set<SubdomainID> preexisting_subdomain_ids;
   input_mesh.subdomain_ids(preexisting_subdomain_ids);
   if (preexisting_subdomain_ids.empty())
     return 0;
   else
   {
     const auto highest_subdomain_id =
         *std::max_element(preexisting_subdomain_ids.begin(), preexisting_subdomain_ids.end());
     mooseAssert(highest_subdomain_id < std::numeric_limits<SubdomainID>::max(),
                 "A SubdomainID with max possible value was found");
     return highest_subdomain_id + 1;
   }
 }

◆ getSubdomainID() [1/2]

SubdomainID MooseMeshUtils::getSubdomainID	(	const SubdomainName &	subdomain_name,
		const MeshBase &	mesh
	)

Gets the subdomain ID associated with the given SubdomainName.

This is needed because the SubdomainName can be either an ID or a name. If it is a name, the mesh is queried for the ID associated with said name.

◆ getSubdomainID() [2/2]

SubdomainID MooseMeshUtils::getSubdomainID	(	const SubdomainName &	subdomain_name,
		const MeshBase &	mesh
	)

Definition at line 251 of file MooseMeshUtils.C.

Referenced by hasSubdomainName().

 {
   if (subdomain_name == "ANY_BLOCK_ID")
     mooseError("getSubdomainID() does not work with \"ANY_BLOCK_ID\"");
 
   SubdomainID id = Moose::INVALID_BLOCK_ID;
   if (subdomain_name.empty())
     return id;
 
   if (!MooseUtils::isDigits(subdomain_name))
     id = mesh.get_id_by_name(subdomain_name);
   else
     id = getIDFromName<SubdomainName, SubdomainID>(subdomain_name);
 
   return id;
 }

◆ getSubdomainIDs() [1/2]

std::vector< subdomain_id_type > MooseMeshUtils::getSubdomainIDs	(	const libMesh::MeshBase &	mesh,
		const std::vector< SubdomainName > &	subdomain_name
	)

Get the associated subdomainIDs for the subdomain names that are passed in.

Parameters

mesh	The mesh
subdomain_name	The names of the subdomains

Returns: The subdomain ids from the passed subdomain names.

Definition at line 199 of file MooseMeshUtils.C.

Referenced by FEProblemBase::checkProblemIntegrity(), convertBlockToMesh(), CoarsenBlockGenerator::generate(), BlockDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RefineBlockGenerator::generate(), getSubdomainIDs(), MooseMesh::getSubdomainIDs(), BlockWeightedPartitioner::initialize(), LibmeshPartitioner::prepareBlocksForSubdomainPartitioner(), SurfaceMeshGeneratorBase::setup(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), and MeshTriangulationUtils::triangulateWithDelaunay().

 {
   std::vector<subdomain_id_type> ids;
 
   // shortcut for "ANY_BLOCK_ID"
   if (subdomain_names.size() == 1 && subdomain_names[0] == "ANY_BLOCK_ID")
   {
     // since get_mesh_subdomains() requires a prepared mesh, we need to check that here
     mooseAssert(mesh.is_prepared(),
                 "getSubdomainIDs() should only be called on a prepared mesh if ANY_BLOCK_ID is "
                 "used to query all block IDs");
     ids.assign(mesh.get_mesh_subdomains().begin(), mesh.get_mesh_subdomains().end());
     return ids;
   }
 
   // loop through subdomain names and get IDs (this preserves the order of subdomain_names)
   ids.resize(subdomain_names.size());
   for (auto i : index_range(subdomain_names))
   {
     if (subdomain_names[i] == "ANY_BLOCK_ID")
       mooseError("getSubdomainIDs() accepts \"ANY_BLOCK_ID\" if and only if it is the only "
                  "subdomain name being queried.");
     ids[i] = MooseMeshUtils::getSubdomainID(subdomain_names[i], mesh);
   }
 
   return ids;
 }

◆ getSubdomainIDs() [2/2]

std::set< subdomain_id_type > MooseMeshUtils::getSubdomainIDs	(	const libMesh::MeshBase &	mesh,
		const std::set< SubdomainName > &	subdomain_name
	)

Definition at line 228 of file MooseMeshUtils.C.

 {
   const auto blk_ids = getSubdomainIDs(
       mesh, std::vector<SubdomainName>(subdomain_names.begin(), subdomain_names.end()));
   return {blk_ids.begin(), blk_ids.end()};
 }

◆ hasBoundaryID() [1/2]

bool MooseMeshUtils::hasBoundaryID	(	const MeshBase &	input_mesh,
		const BoundaryID	id
	)

Whether a particular boundary ID exists in the mesh.

Parameters

input	mesh over which to determine boundary IDs
boundary	ID

Referenced by MooseMeshXYCuttingUtils::boundaryTriElemImprover(), AdvancedExtruderGenerator::generate(), and XYMeshLineCutter::generate().

◆ hasBoundaryID() [2/2]

bool MooseMeshUtils::hasBoundaryID	(	const MeshBase &	input_mesh,
		const BoundaryID	id
	)

Definition at line 552 of file MooseMeshUtils.C.

Referenced by hasBoundaryNameOrID().

 {
   const BoundaryInfo & boundary_info = input_mesh.get_boundary_info();
   std::set<boundary_id_type> boundary_ids = boundary_info.get_boundary_ids();
 
   // On a distributed mesh we may have boundary IDs that only exist on
   // other processors
   if (!input_mesh.is_replicated())
     input_mesh.comm().set_union(boundary_ids);
 
   return boundary_ids.count(id) && (id != Moose::INVALID_BOUNDARY_ID);
 }

◆ hasBoundaryName() [1/2]

bool MooseMeshUtils::hasBoundaryName	(	const MeshBase &	mesh,
		const BoundaryName &	name
	)

Whether a particular boundary name exists in the mesh.

This returns true if name is non-empty and is a name (not ID) that exists.

Parameters

mesh	mesh over which to determine boundary names
name	boundary name

◆ hasBoundaryName() [2/2]

bool MooseMeshUtils::hasBoundaryName	(	const MeshBase &	mesh,
		const BoundaryName &	name
	)

Definition at line 566 of file MooseMeshUtils.C.

 {
   const BoundaryInfo & boundary_info = mesh.get_boundary_info();
   const BoundaryID id = boundary_info.get_id_by_name(name);
   return id != Moose::INVALID_BOUNDARY_ID;
 }

◆ hasBoundaryNameOrID() [1/2]

bool MooseMeshUtils::hasBoundaryNameOrID	(	const MeshBase &	mesh,
		const BoundaryName &	name_or_id
	)

Whether a particular boundary name or ID exists in the mesh.

This returns true if name_or_id is non-empty and either a name or ID that exists.

Parameters

mesh	mesh over which to determine boundary names
name_or_id	boundary name or ID

Referenced by createSubdomainFromSidesets(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), BreakBoundaryOnSubdomainGenerator::generate(), MeshDiagnosticsGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), MultiAppGeneralFieldTransfer::initialSetup(), and MooseMeshElementConversionUtils::transitionLayerGenerator().

◆ hasBoundaryNameOrID() [2/2]

bool MooseMeshUtils::hasBoundaryNameOrID	(	const MeshBase &	mesh,
		const BoundaryName &	name_or_id
	)

Definition at line 574 of file MooseMeshUtils.C.

 {
   const auto id = getBoundaryID(name_or_id, mesh);
   return hasBoundaryID(mesh, id);
 }

◆ hasSubdomainID() [1/2]

bool MooseMeshUtils::hasSubdomainID	(	const MeshBase &	input_mesh,
		const SubdomainID &	id
	)

Whether a particular subdomain ID exists in the mesh.

Parameters

input	mesh over which to determine subdomain IDs
subdomain	ID

Referenced by MooseMeshElementConversionUtils::assignConvertedElementsSubdomainNameSuffix(), BlockDeletionGenerator::generate(), CoarsenBlockGenerator::generate(), RefineBlockGenerator::generate(), BreakMeshByElementGenerator::generate(), AdvancedExtruderGenerator::generate(), MeshExtruderGenerator::generate(), and ManifoldSubdomainGenerator::generate().

◆ hasSubdomainID() [2/2]

bool MooseMeshUtils::hasSubdomainID	(	const MeshBase &	input_mesh,
		const SubdomainID &	id
	)

Definition at line 531 of file MooseMeshUtils.C.

Referenced by hasSubdomainName().

 {
   std::set<SubdomainID> mesh_blocks;
   input_mesh.subdomain_ids(mesh_blocks);
 
   // On a distributed mesh we may have sideset IDs that only exist on
   // other processors
   if (!input_mesh.is_replicated())
     input_mesh.comm().set_union(mesh_blocks);
 
   return mesh_blocks.count(id) && (id != Moose::INVALID_BLOCK_ID);
 }

◆ hasSubdomainName() [1/2]

bool MooseMeshUtils::hasSubdomainName	(	const MeshBase &	input_mesh,
		const SubdomainName &	name
	)

Whether a particular subdomain name exists in the mesh.

Parameters

input	mesh over which to determine subdomain names
subdomain	name

Referenced by MooseMeshElementConversionUtils::assignConvertedElementsSubdomainNameSuffix(), MultiAppUserObjectTransfer::execute(), UniqueExtraIDMeshGenerator::generate(), BreakMeshByBlockGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), ParsedExtraElementIDGenerator::generate(), ManifoldSubdomainGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), MultiAppDofCopyTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), SurfaceMeshGeneratorBase::setup(), NodeSetsGeneratorBase::setup(), and SideSetsGeneratorBase::setup().

◆ hasSubdomainName() [2/2]

bool MooseMeshUtils::hasSubdomainName	(	const MeshBase &	input_mesh,
		const SubdomainName &	name
	)

Definition at line 545 of file MooseMeshUtils.C.

 {
   const auto id = getSubdomainID(name, input_mesh);
   return hasSubdomainID(input_mesh, id);
 }

◆ idSwapParametersProcessor()

template<typename T >

void MooseMeshUtils::idSwapParametersProcessor	(	const std::string &	class_name,
		const std::string &	id_name,
		const std::vector< std::vector< T >> &	id_swaps,
		std::vector< std::unordered_map< T, T >> &	id_swap_pairs,
		const unsigned int	row_index_shift = `0`
	)

Reprocess the swap related input parameters to make pairs out of them to ease further processing.

Parameters

class_name	name of the mesh generator class used for exception messages
id_name	name of the parameter to be swapped used for exception messages
id_swaps	vector of vectors of the ids to be swapped
id_swap_pairs	vector of maps of the swapped pairs
row_index_shift	shift to be applied to the row index in the exception messages (useful when this method is utilized to process a fraction of a long vector)

Definition at line 420 of file MooseMeshUtils.h.

Referenced by AdvancedExtruderGenerator::AdvancedExtruderGenerator(), and extraElemIntegerSwapParametersProcessor().

 {
   id_swap_pairs.resize(id_swaps.size());
   for (const auto i : index_range(id_swaps))
   {
     const auto & swaps = id_swaps[i];
     auto & swap_pairs = id_swap_pairs[i];
 
     if (swaps.size() % 2)
       throw MooseException("Row ",
                            row_index_shift + i + 1,
                            " of ",
                            id_name,
                            " in ",
                            class_name,
                            " does not contain an even number of entries! Num entries: ",
                            swaps.size());
 
     swap_pairs.reserve(swaps.size() / 2);
     for (unsigned int j = 0; j < swaps.size(); j += 2)
       swap_pairs[swaps[j]] = swaps[j + 1];
   }
 }

◆ isCoPlanar() [1/6]

bool MooseMeshUtils::isCoPlanar	(	const std::vector< Point > &	vec_pts,
		const Point	plane_nvec,
		const Point	fixed_pt
	)

Decides whether all the Points of a vector of Points are in a plane that is defined by a normal vector and an inplane Point.

Parameters

vec_pts	vector of points to be examined
plane_nvec	normal vector of the plane
fixed_pt	a Point in the plane

Returns: whether all the Points are in the given plane

Referenced by Positions::arePositionsCoplanar(), FillBetweenPointVectorsTools::fillBetweenPointVectorsGenerator(), and SurfaceMeshGeneratorBase::get2DElemNormal().

◆ isCoPlanar() [2/6]

bool MooseMeshUtils::isCoPlanar	(	const std::vector< Point > &	vec_pts,
		const Point	plane_nvec
	)

Decides whether all the Points of a vector of Points are in a plane with a given normal vector.

Parameters

vec_pts	vector of points to be examined
plane_nvec	normal vector of the plane

Returns: whether all the Points are in the same plane with the given normal vector

◆ isCoPlanar() [3/6]

bool MooseMeshUtils::isCoPlanar ( const std::vector< Point > & vec_pts )

Decides whether all the Points of a vector of Points are coplanar.

Parameters

vec_pts vector of points to be examined

Returns: whether all the Points are in a same plane

◆ isCoPlanar() [4/6]

bool MooseMeshUtils::isCoPlanar	(	const std::vector< Point > &	vec_pts,
		const Point	plane_nvec,
		const Point	fixed_pt
	)

Definition at line 457 of file MooseMeshUtils.C.

 {
   for (const auto & pt : vec_pts)
     if (!MooseUtils::absoluteFuzzyEqual((pt - fixed_pt) * plane_nvec, 0.0))
       return false;
   return true;
 }

◆ isCoPlanar() [5/6]

bool MooseMeshUtils::isCoPlanar	(	const std::vector< Point > &	vec_pts,
		const Point	plane_nvec
	)

Definition at line 466 of file MooseMeshUtils.C.

 {
   return isCoPlanar(vec_pts, plane_nvec, vec_pts.front());
 }

◆ isCoPlanar() [6/6]

bool MooseMeshUtils::isCoPlanar ( const std::vector< Point > & vec_pts )

Definition at line 472 of file MooseMeshUtils.C.

Referenced by isCoPlanar().

 {
   // Assuming that overlapped Points are allowed, the Points that are overlapped with vec_pts[0] are
   // removed before further calculation.
   std::vector<Point> vec_pts_nonzero{vec_pts[0]};
   for (const auto i : index_range(vec_pts))
     if (!MooseUtils::absoluteFuzzyEqual((vec_pts[i] - vec_pts[0]).norm(), 0.0))
       vec_pts_nonzero.push_back(vec_pts[i]);
   // 3 or fewer points are always coplanar
   if (vec_pts_nonzero.size() <= 3)
     return true;
   else
   {
     for (const auto i : make_range(vec_pts_nonzero.size() - 1))
     {
       const Point tmp_pt = (vec_pts_nonzero[i] - vec_pts_nonzero[0])
                                .cross(vec_pts_nonzero[i + 1] - vec_pts_nonzero[0]);
       // if the three points are not collinear, use cross product as the normal vector of the plane
       if (!MooseUtils::absoluteFuzzyEqual(tmp_pt.norm(), 0.0))
         return isCoPlanar(vec_pts_nonzero, tmp_pt.unit());
     }
   }
   // If all the points are collinear, they are also coplanar
   return true;
 }

◆ makeOrderedNodeList() [1/2]

void MooseMeshUtils::makeOrderedNodeList	(	std::vector< std::pair< dof_id_type, dof_id_type >> &	node_assm,
		std::vector< dof_id_type > &	elem_id_list,
		std::vector< dof_id_type > &	midpoint_node_list,
		std::vector< dof_id_type > &	ordered_node_list,
		std::vector< dof_id_type > &	ordered_elem_id_list
	)

Convert a list of sides in the form of a vector of pairs of node ids into a list of ordered nodes based on connectivity.

Parameters

node_assm	vector of pairs of node ids that represent the sides
elem_id_list	vector of element ids that represent the elements that contain the sides
midpoint_node_list	vector of node ids that represent the midpoints of the sides for quadratic sides
ordered_node_list	vector of node ids that represent the ordered nodes
ordered_elem_id_list	vector of element corresponding to the ordered nodes

Definition at line 581 of file MooseMeshUtils.C.

Referenced by MooseMeshXYCuttingUtils::boundaryTriElemImprover(), FillBetweenPointVectorsTools::isClosedLoop(), and makeOrderedNodeList().

 {
   // a flag to indicate if the ordered_node_list has been reversed
   bool is_flipped = false;
   // Start from the first element, try to find a chain of nodes
   mooseAssert(node_assm.size(), "Node list must not be empty");
   ordered_node_list.push_back(node_assm.front().first);
   if (midpoint_node_list.front() != DofObject::invalid_id)
     ordered_node_list.push_back(midpoint_node_list.front());
   ordered_node_list.push_back(node_assm.front().second);
   ordered_elem_id_list.push_back(elem_id_list.front());
   // Remove the element that has just been added to ordered_node_list
   node_assm.erase(node_assm.begin());
   midpoint_node_list.erase(midpoint_node_list.begin());
   elem_id_list.erase(elem_id_list.begin());
   const unsigned int node_assm_size_0 = node_assm.size();
   for (unsigned int i = 0; i < node_assm_size_0; i++)
   {
     // Find nodes to expand the chain
     dof_id_type end_node_id = ordered_node_list.back();
     auto isMatch1 = [end_node_id](std::pair<dof_id_type, dof_id_type> old_id_pair)
     { return old_id_pair.first == end_node_id; };
     auto isMatch2 = [end_node_id](std::pair<dof_id_type, dof_id_type> old_id_pair)
     { return old_id_pair.second == end_node_id; };
     auto result = std::find_if(node_assm.begin(), node_assm.end(), isMatch1);
     bool match_first;
     if (result == node_assm.end())
     {
       match_first = false;
       result = std::find_if(node_assm.begin(), node_assm.end(), isMatch2);
     }
     else
     {
       match_first = true;
     }
     // If found, add the node to boundary_ordered_node_list
     if (result != node_assm.end())
     {
       const auto elem_index = std::distance(node_assm.begin(), result);
       if (midpoint_node_list[elem_index] != DofObject::invalid_id)
         ordered_node_list.push_back(midpoint_node_list[elem_index]);
       ordered_node_list.push_back(match_first ? (*result).second : (*result).first);
       node_assm.erase(result);
       midpoint_node_list.erase(midpoint_node_list.begin() + elem_index);
       ordered_elem_id_list.push_back(elem_id_list[elem_index]);
       elem_id_list.erase(elem_id_list.begin() + elem_index);
     }
     // If there are still elements in node_assm and result ==
     // node_assm.end(), this means the curve is not a loop, the
     // ordered_node_list is flipped and try the other direction that has not
     // been examined yet.
     else
     {
       if (is_flipped)
         // Flipped twice; this means the node list has at least two segments.
         throw MooseException("The node list provided has more than one segments.");
 
       // mark the first flip event.
       is_flipped = true;
       std::reverse(ordered_node_list.begin(), ordered_node_list.end());
       std::reverse(midpoint_node_list.begin(), midpoint_node_list.end());
       std::reverse(ordered_elem_id_list.begin(), ordered_elem_id_list.end());
       // As this iteration is wasted, set the iterator backward
       i--;
     }
   }
 }

◆ makeOrderedNodeList() [2/2]

void MooseMeshUtils::makeOrderedNodeList	(	std::vector< std::pair< dof_id_type, dof_id_type >> &	node_assm,
		std::vector< dof_id_type > &	elem_id_list,
		std::vector< dof_id_type > &	ordered_node_list,
		std::vector< dof_id_type > &	ordered_elem_id_list
	)

Convert a list of sides in the form of a vector of pairs of node ids into a list of ordered nodes based on connectivity.

Parameters

node_assm	vector of pairs of node ids that represent the sides
elem_id_list	vector of element ids that represent the elements that contain the sides
ordered_node_list	vector of node ids that represent the ordered nodes
ordered_elem_id_list	vector of element corresponding to the ordered nodes

Definition at line 654 of file MooseMeshUtils.C.

 {
   std::vector<dof_id_type> dummy_midpoint_node_list(node_assm.size(), DofObject::invalid_id);
   makeOrderedNodeList(
       node_assm, elem_id_list, dummy_midpoint_node_list, ordered_node_list, ordered_elem_id_list);
 }

◆ mergeBoundaryIDsWithSameName() [1/2]

void MooseMeshUtils::mergeBoundaryIDsWithSameName ( MeshBase & mesh )

Definition at line 38 of file MooseMeshUtils.C.

 {
   // We check if we have the same boundary name with different IDs. If we do, we assign the
   // first ID to every occurrence.
   const auto & side_bd_name_map = mesh.get_boundary_info().get_sideset_name_map();
   const auto & node_bd_name_map = mesh.get_boundary_info().get_nodeset_name_map();
   std::map<boundary_id_type, boundary_id_type> same_name_ids;
 
   auto populate_map = [](const std::map<boundary_id_type, std::string> & map,
                          std::map<boundary_id_type, boundary_id_type> & same_ids)
   {
     for (const auto & pair_outer : map)
       for (const auto & pair_inner : map)
         // The last condition is needed to make sure we only store one combination
         if (pair_outer.second == pair_inner.second && pair_outer.first != pair_inner.first &&
             same_ids.find(pair_inner.first) == same_ids.end())
           same_ids[pair_outer.first] = pair_inner.first;
   };
 
   populate_map(side_bd_name_map, same_name_ids);
   populate_map(node_bd_name_map, same_name_ids);
 
   for (const auto & [id1, id2] : same_name_ids)
     mesh.get_boundary_info().renumber_id(id2, id1);
 }

◆ mergeBoundaryIDsWithSameName() [2/2]

void MooseMeshUtils::mergeBoundaryIDsWithSameName ( MeshBase & mesh )

Merges the boundary IDs of boundaries that have the same names but different IDs.

Parameters

mesh	The input mesh whose boundaries we will modify

Referenced by MeshRepairGenerator::generate(), and StitchMeshGenerator::generate().

◆ meshCentroidCalculator() [1/2]

Point MooseMeshUtils::meshCentroidCalculator ( const MeshBase & mesh )

Calculates the centroid of a MeshBase.

Parameters

mesh	input mesh whose centroid needs to be calculated

Returns: a Point corresponding to the mesh centroid

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), FillBetweenSidesetsGenerator::generate(), AdvancedExtruderGenerator::generate(), and MultiAppPositions::initialize().

◆ meshCentroidCalculator() [2/2]

Point MooseMeshUtils::meshCentroidCalculator ( const MeshBase & mesh )

Definition at line 280 of file MooseMeshUtils.C.

 {
   Point centroid_pt = Point(0.0, 0.0, 0.0);
   Real vol_tmp = 0.0;
   for (const auto & elem : mesh.active_local_element_ptr_range())
   {
     Real elem_vol = elem->volume();
     centroid_pt += (elem->true_centroid()) * elem_vol;
     vol_tmp += elem_vol;
   }
   mesh.comm().sum(centroid_pt);
   mesh.comm().sum(vol_tmp);
   centroid_pt /= vol_tmp;
   return centroid_pt;
 }

◆ swapNodesInElem() [1/2]

void MooseMeshUtils::swapNodesInElem	(	Elem &	elem,
		const unsigned int	nd1,
		const unsigned int	nd2
	)

Swap two nodes within an element.

Parameters

elem	element whose nodes need to be swapped
nd1	index of the first node to be swapped
nd2	index of the second node to be swapped

Referenced by AdvancedExtruderGenerator::generate().

◆ swapNodesInElem() [2/2]

void MooseMeshUtils::swapNodesInElem	(	Elem &	elem,
		const unsigned int	nd1,
		const unsigned int	nd2
	)

Definition at line 665 of file MooseMeshUtils.C.

 {
   Node * n_temp = elem.node_ptr(nd1);
   elem.set_node(nd1, elem.node_ptr(nd2));
   elem.set_node(nd2, n_temp);
 }

Classes

Functions

Function Documentation

◆ addExternalBoundary() [1/2]

◆ addExternalBoundary() [2/2]

◆ boundaryCentroidCalculator() [1/2]

◆ boundaryCentroidCalculator() [2/2]

◆ boundaryWeightedNormal() [1/2]

◆ boundaryWeightedNormal() [2/2]

◆ buildBoundaryMesh() [1/2]

◆ buildBoundaryMesh() [2/2]

◆ buildBoundaryNodeToElemMap() [1/2]

◆ buildBoundaryNodeToElemMap() [2/2]

◆ buildLoopBoundaryOf2DMesh() [1/2]

◆ buildLoopBoundaryOf2DMesh() [2/2]

◆ buildPolyLineMesh() [1/6]

◆ buildPolyLineMesh() [2/6]

◆ buildPolyLineMesh() [3/6]

◆ buildPolyLineMesh() [4/6]

◆ buildPolyLineMesh() [5/6]

◆ buildPolyLineMesh() [6/6]

◆ changeBoundaryId() [1/2]

◆ changeBoundaryId() [2/2]

◆ changeSubdomainId() [1/2]

◆ changeSubdomainId() [2/2]

◆ computeDistanceToAxis()

◆ computeFiniteVolumeCoords()

◆ computeMaxDistanceToAxis() [1/2]

◆ computeMaxDistanceToAxis() [2/2]

◆ convertBlockToMesh() [1/2]

◆ convertBlockToMesh() [2/2]

◆ coordTransformFactor()

◆ coordTransformFactorRZGeneral()

◆ copyIntoMesh() [1/2]

◆ copyIntoMesh() [2/2]

◆ createSubdomainFromSidesets() [1/2]

◆ createSubdomainFromSidesets() [2/2]

◆ extraElemIntegerSwapParametersProcessor()

◆ getBoundaryID() [1/2]

◆ getBoundaryID() [2/2]

◆ getBoundaryIDs() [1/2]

◆ getBoundaryIDs() [2/2]

◆ getBoundaryIDSet()

◆ getBoundaryNodes() [1/2]

◆ getBoundaryNodes() [2/2]

◆ getExtraIDUniqueCombinationMap() [1/2]

◆ getExtraIDUniqueCombinationMap() [2/2]

◆ getIDFromName()

◆ getNextFreeBoundaryID() [1/2]

◆ getNextFreeBoundaryID() [2/2]

◆ getNextFreeSubdomainID() [1/2]

◆ getNextFreeSubdomainID() [2/2]

◆ getSubdomainID() [1/2]

◆ getSubdomainID() [2/2]

◆ getSubdomainIDs() [1/2]

◆ getSubdomainIDs() [2/2]

◆ hasBoundaryID() [1/2]

◆ hasBoundaryID() [2/2]

◆ hasBoundaryName() [1/2]

◆ hasBoundaryName() [2/2]

◆ hasBoundaryNameOrID() [1/2]

◆ hasBoundaryNameOrID() [2/2]

◆ hasSubdomainID() [1/2]

◆ hasSubdomainID() [2/2]

◆ hasSubdomainName() [1/2]

◆ hasSubdomainName() [2/2]

◆ idSwapParametersProcessor()

◆ isCoPlanar() [1/6]

◆ isCoPlanar() [2/6]

◆ isCoPlanar() [3/6]

◆ isCoPlanar() [4/6]

◆ isCoPlanar() [5/6]

◆ isCoPlanar() [6/6]

◆ makeOrderedNodeList() [1/2]

◆ makeOrderedNodeList() [2/2]

◆ mergeBoundaryIDsWithSameName() [1/2]

◆ mergeBoundaryIDsWithSameName() [2/2]

◆ meshCentroidCalculator() [1/2]

◆ meshCentroidCalculator() [2/2]

◆ swapNodesInElem() [1/2]