MooseMeshUtils Namespace Reference

Classes
struct	ElemSidePair

Functions
void	mergeBoundaryIDsWithSameName (MeshBase &mesh)
	Merges the boundary IDs of boundaries that have the same names but different IDs.
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.
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.
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.
std::vector< BoundaryID >	getBoundaryIDs (const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown)
	Gets the boundary IDs with their names.
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.
BoundaryID	getBoundaryID (const BoundaryName &boundary_name, const MeshBase &mesh)
	Gets the boundary ID associated with the given BoundaryName.
std::set< std::pair< BoundaryName, BoundaryID > >	getAllBoundaryNamesAndIDs (const libMesh::MeshBase &mesh)
	Get all boundary names and IDs from a mesh.
SubdomainID	getSubdomainID (const SubdomainName &subdomain_name, const MeshBase &mesh)
	Gets the subdomain ID associated with the given SubdomainName.
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.
std::set< subdomain_id_type >	getSubdomainIDs (const libMesh::MeshBase &mesh, const std::set< SubdomainName > &subdomain_name)
std::set< std::pair< SubdomainName, SubdomainID > >	getAllSubdomainNamesAndIDs (const libMesh::MeshBase &mesh)
	Get all subdomain names and ids from a mesh.
Point	meshCentroidCalculator (const MeshBase &mesh)
	Calculates the centroid of a MeshBase.
Point	boundaryCentroidCalculator (const BoundaryName &boundary, MeshBase &mesh)
	Calculates the centroid of a boundary on a mesh.
RealVectorValue	boundaryWeightedNormal (const BoundaryName &boundary, MeshBase &mesh)
	Calculates the side-volume weighted (side-vertex) average normal of a boundary on a mesh.
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.
template<typename P , typename C >
C	computeDistanceToAxis (const P &point, const Point &origin, const RealVectorValue &direction)
	Computes the distance to a general axis.
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.
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.
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.
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.
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.
bool	isCoPlanar (const std::vector< Point > &vec_pts)
	Decides whether all the Points of a vector of Points are coplanar.
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.
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.
bool	hasSubdomainID (const MeshBase &input_mesh, const SubdomainID &id)
	Whether a particular subdomain ID exists in the mesh.
bool	hasSubdomainName (const MeshBase &input_mesh, const SubdomainName &name)
	Whether a particular subdomain name exists in the mesh.
bool	hasBoundaryID (const MeshBase &input_mesh, const BoundaryID id)
	Whether a particular boundary ID exists in the mesh.
bool	hasBoundaryName (const MeshBase &mesh, const BoundaryName &name)
	Whether a particular boundary name exists in the mesh.
bool	hasBoundaryNameOrID (const MeshBase &mesh, const BoundaryName &name_or_id)
	Whether a particular boundary name or ID exists in the mesh.
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.
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.
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.
void	swapNodesInElem (Elem &elem, const unsigned int nd1, const unsigned int nd2)
	Swap two nodes within an element.
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.
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.
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.
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.
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.
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.
void	createSubdomainFromSidesets (MeshBase &mesh, std::vector< BoundaryName > boundary_names, const SubdomainID new_subdomain_id, const SubdomainName &new_subdomain_name)
	Create a new subdomain by generating new side elements from a list of sidesets in a given mesh.
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.
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.
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.
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.
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.
void	addExternalBoundary (MeshBase &mesh, const BoundaryID extern_bid, bool &has_external_bid)
	Adds a sideset for the external boundary of the mesh (e.g.
std::vector< unsigned int >	nodalQuadraturePointToNodeMap (const Elem &elem, const std::vector< Point > &q_points)
	Match the points of a nodal quadrature rule (e.g.
void	changeBoundaryId (MeshBase &mesh, const boundary_id_type old_id, const boundary_id_type new_id, bool delete_prev)
std::vector< boundary_id_type >	getBoundaryIDs (const MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown)
std::vector< boundary_id_type >	getBoundaryIDs (const MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown, const std::set< BoundaryID > &mesh_boundary_ids)
std::set< BoundaryID >	getBoundaryIDSet (const MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown)
std::set< std::pair< BoundaryName, BoundaryID > >	getAllBoundaryNamesAndIDs (const MeshBase &mesh)
std::vector< subdomain_id_type >	getSubdomainIDs (const MeshBase &mesh, const std::vector< SubdomainName > &subdomain_names)
std::set< subdomain_id_type >	getSubdomainIDs (const MeshBase &mesh, const std::set< SubdomainName > &subdomain_names)
std::set< std::pair< SubdomainName, SubdomainID > >	getAllSubdomainNamesAndIDs (const MeshBase &mesh)

Function Documentation

addExternalBoundary()

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)

Definition at line 1548 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);
      }
}

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

boundaryCentroidCalculator()

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

Definition at line 326 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);
 
  if (volume_sum == 0)
  {
    mooseWarning("Boundary centroid was requested but boundary '" + boundary + "' is empty.");
    return Point(0.);
  }
  return volume_weighted_centroid_sum / volume_sum;
}

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

boundaryWeightedNormal()

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

Definition at line 364 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;
}

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

buildBoundaryMesh()

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

Definition at line 739 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()

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

Definition at line 1002 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());
 
  // 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;
}

Referenced by buildLoopBoundaryOf2DMesh().

buildLoopBoundaryOf2DMesh()

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

Definition at line 787 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;
}

Referenced by SurfaceSubdomainsDelaunayRemesher::General2DDelaunay().

buildPolyLineMesh() [1/3]

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

Definition at line 1522 of file MooseMeshUtils.C.

{
  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);
}

buildPolyLineMesh() [2/3]

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)

Definition at line 1510 of file MooseMeshUtils.C.

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

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

buildPolyLineMesh() [3/3]

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)

Definition at line 1402 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();
}

changeBoundaryId() [1/2]

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

Definition at line 63 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();
}

changeBoundaryId() [2/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(), MeshTriangulationUtils::finalizeTriangulation(), FillBetweenSidesetsGenerator::generate(), XYDelaunayGenerator::generate(), and MooseMeshElementConversionUtils::transitionLayerGenerator().

changeSubdomainId()

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

Definition at line 298 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 233 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 267 of file MooseMeshUtils.h.

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

computeMaxDistanceToAxis()

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

Definition at line 397 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;
}

Referenced by AdvancedExtruderGenerator::generate().

convertBlockToMesh()

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

Definition at line 1159 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);
 
  // Our source is non-const, so we can fix any missing caches
  if (!source_mesh.preparation().has_cached_elem_data)
    source_mesh.cache_elem_data();
 
  // 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.set_subdomain_name(sbd_id, source_mesh.subdomain_name(sbd_id));
}

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

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, 2*pi*r for cylindrical coordinate systems, and 4*pi*r^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 199 of file MooseMeshUtils.h.

{
  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");
  }
}

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

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 259 of file MooseMeshUtils.h.

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

Referenced by coordTransformFactor().

copyIntoMesh()

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

Definition at line 1246 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));
}

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

createSubdomainFromSidesets()

void MooseMeshUtils::createSubdomainFromSidesets	(	MeshBase &	mesh,
		std::vector< BoundaryName >	boundary_names,
		const SubdomainID	new_subdomain_id,
		const SubdomainName &	new_subdomain_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.

Definition at line 1060 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.complete_preparation();
    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();
  }
 
  // Use libmesh's BoundaryInfo::add_elements to create lower-d elements with interior_parent
  // pointers and subdomain IDs set in one pass.
  auto & unstr_mesh = libMesh::cast_ref<UnstructuredMesh &>(mesh);
  unstr_mesh.get_boundary_info().add_elements(sidesets, unstr_mesh, false, {new_block_id});
 
  // Assign block name, if provided
  if (new_subdomain_name.size())
    mesh.set_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);
}

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

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 707 of file MooseMeshUtils.C.

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

Referenced by AdvancedExtruderGenerator::AdvancedExtruderGenerator().

getAllBoundaryNamesAndIDs() [1/2]

std::set< std::pair< BoundaryName, BoundaryID > > MooseMeshUtils::getAllBoundaryNamesAndIDs

(

const libMesh::MeshBase &

mesh

)

Get all boundary names and IDs from a mesh.

Parameters

mesh	the mesh of interest

Returns

a set of pairs of boundary names and ids

Referenced by AdvancedExtruderGenerator::generate(), and LowerDBlockFromSidesetGenerator::generate().

getAllBoundaryNamesAndIDs() [2/2]

std::set< std::pair< BoundaryName, BoundaryID > > MooseMeshUtils::getAllBoundaryNamesAndIDs

(

const MeshBase &

mesh

)

Definition at line 200 of file MooseMeshUtils.C.

{
  std::set<std::pair<BoundaryName, BoundaryID>> boundaries;
  const auto & binfo = mesh.get_boundary_info();
  const auto & boundary_ids = binfo.get_boundary_ids();
  for (const auto id : boundary_ids)
  {
    // if neither a sideset or nodeset, then empty
    if (binfo.get_sideset_name(id).size())
      boundaries.insert(std::make_pair(binfo.get_sideset_name(id), id));
    else
      boundaries.insert(std::make_pair(binfo.get_nodeset_name(id), id));
  }
  return boundaries;
}

getAllSubdomainNamesAndIDs() [1/2]

std::set< std::pair< SubdomainName, SubdomainID > > MooseMeshUtils::getAllSubdomainNamesAndIDs

(

const libMesh::MeshBase &

mesh

)

Get all subdomain names and ids from a mesh.

Parameters

mesh	the mesh of interest

Returns

a set of pairs of subdomain names and ids

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

getAllSubdomainNamesAndIDs() [2/2]

std::set< std::pair< SubdomainName, SubdomainID > > MooseMeshUtils::getAllSubdomainNamesAndIDs

(

const MeshBase &

mesh

)

Definition at line 254 of file MooseMeshUtils.C.

{
  std::set<std::pair<SubdomainName, SubdomainID>> subdomains;
  std::set<subdomain_id_type> subdomain_ids;
  mesh.subdomain_ids(subdomain_ids, /*global*/ true);
  for (const auto id : subdomain_ids)
    subdomains.insert(std::make_pair(mesh.subdomain_name(id), id));
  return subdomains;
}

getBoundaryID()

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.

Definition at line 265 of file MooseMeshUtils.C.

{
  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;
}

Referenced by BoundaryDeletionGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), MoveBoundaryNodesToCurveGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), RenameBoundaryGenerator::generate(), MooseMesh::getBoundaryID(), hasBoundaryNameOrID(), MeshTriangulationUtils::outerBoundaryIds(), Moose::PeriodicBCHelper::setupManualPeriodicBoundaries(), and MooseMeshElementConversionUtils::transitionLayerGenerator().

getBoundaryIDs() [1/4]

std::vector< BoundaryID > 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.

If generate_unknown is true and !mesh.preparation().has_boundary_id_sets, this must be called across all ranks for synchronization.

getBoundaryIDs() [2/4]

std::vector< BoundaryID > 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 generate_unknown is true and !mesh.preparation().has_boundary_id_sets, this must be called across all ranks for synchronization.

Referenced by BoundaryPreservedMarker::BoundaryPreservedMarker(), BoundaryLayerUtils::buildBoundaryLayerRing(), buildPolyLineMesh(), MeshExtruderGenerator::changeID(), createSubdomainFromSidesets(), MeshTriangulationUtils::finalizeTriangulation(), FunctorNodalCorrector::FunctorNodalCorrector(), Boundary2DDelaunayGenerator::General2DDelaunay(), AdvancedExtruderGenerator::generate(), BoundaryLayerSubdomainGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), CoarsenSurfaceMeshAlongSidesetGenerator::generate(), ElementDeletionGeneratorBase::generate(), ExtraNodesetGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MeshDiagnosticsGenerator::generate(), ParsedGenerateNodeset::generate(), ParsedGenerateSideset::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), RefineSidesetGenerator::generate(), SideSetsAroundSubdomainGenerator::generate(), SideSetsBetweenSubdomainsGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), SideSetsFromNormalsGenerator::generate(), SideSetsFromPointsGenerator::generate(), StackGenerator::generate(), XYDelaunayGenerator::generate(), XYTriangleBoundaryLayerGenerator::generate(), PatternedMeshGenerator::generate(), getBoundaryIDs(), MooseMesh::getBoundaryIDs(), getBoundaryIDSet(), NodeSetsGeneratorBase::setup(), and SideSetsGeneratorBase::setup().

getBoundaryIDs() [3/4]

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

Definition at line 107 of file MooseMeshUtils.C.

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

getBoundaryIDs() [4/4]

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

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 116 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();
 
  /* 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.
   */
  BoundaryID max_boundary_id = 0;
  if (generate_unknown)
  {
    bool has_boundary_id_sets = mesh.preparation().has_boundary_id_sets;
 
    // Ideally, this requirement should be able to be enforced earlier when we
    // get the name maps. However, that preparedness check on sideset and
    // nodeset maps doesn't exist yet.
    if (!has_boundary_id_sets)
      libmesh_parallel_only(mesh.comm());
 
    const auto & bids = has_boundary_id_sets ? boundary_info.get_global_boundary_ids()
                                             : boundary_info.get_boundary_ids();
    if (bids.size())
      max_boundary_id = *(bids.rbegin());
    if (!has_boundary_id_sets)
      mesh.comm().max(max_boundary_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;
}

getBoundaryIDSet() [1/2]

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.

If generate_unknown is true and !mesh.preparation().has_boundary_id_sets, this must be called across all ranks for synchronization.

Referenced by DomainUserObject::DomainUserObject().

getBoundaryIDSet() [2/2]

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

Definition at line 191 of file MooseMeshUtils.C.

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

getBoundaryNodes()

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

Definition at line 1032 of file MooseMeshUtils.C.

{
  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;
}

Referenced by buildBoundaryNodeToElemMap().

getExtraIDUniqueCombinationMap()

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

Definition at line 412 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;
}

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

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

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

Definition at line 553 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);
}

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

getNextFreeSubdomainID()

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

Definition at line 533 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;
  }
}

Referenced by MeshTriangulationUtils::finalizeTriangulation(), Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), AdvancedExtruderGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BoundaryLayerSubdomainGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), LowerDBlockFromSidesetGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), StitchMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), XYZDelaunayGenerator::generate(), TriToQuadConverter::recombine(), MeshRepairGenerator::separateSubdomainsByElementType(), TriToQuadConverter::subdivide(), and MooseMeshElementConversionUtils::transitionLayerGenerator().

getSubdomainID()

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.

Definition at line 280 of file MooseMeshUtils.C.

{
  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;
}

Referenced by MeshTriangulationUtils::finalizeTriangulation(), AdvancedExtruderGenerator::generate(), ManifoldSubdomainGenerator::generate(), ParsedExtraElementIDGenerator::generate(), RenameBlockGenerator::generate(), RenumberBySubdomainGenerator::generate(), StitchMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), XYZDelaunayGenerator::generate(), MooseMesh::getSubdomainID(), getSubdomainIDs(), hasSubdomainName(), TriToQuadConverter::moveSurvivingTriangles(), MooseMeshXYCuttingUtils::quadToTriOnLine(), and MooseMeshXYCuttingUtils::quasiTriElementsFixer().

getSubdomainIDs() [1/4]

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

getSubdomainIDs() [2/4]

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.

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

getSubdomainIDs() [3/4]

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

Definition at line 246 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()};
}

getSubdomainIDs() [4/4]

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

Definition at line 217 of file MooseMeshUtils.C.

{
  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;
}

hasBoundaryID()

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

Definition at line 586 of file MooseMeshUtils.C.

{
  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);
}

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

hasBoundaryName()

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

Definition at line 600 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()

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

Definition at line 608 of file MooseMeshUtils.C.

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

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

hasSubdomainID()

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

Definition at line 565 of file MooseMeshUtils.C.

{
  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);
}

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

hasSubdomainName()

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

Definition at line 579 of file MooseMeshUtils.C.

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

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

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 448 of file MooseMeshUtils.h.

{
  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];
  }
}

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

isCoPlanar() [1/3]

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

Definition at line 506 of file MooseMeshUtils.C.

{
  // 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;
}

isCoPlanar() [2/3]

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

Definition at line 500 of file MooseMeshUtils.C.

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

isCoPlanar() [3/3]

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

Definition at line 491 of file MooseMeshUtils.C.

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

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

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 615 of file MooseMeshUtils.C.

{
  // 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--;
    }
  }
}

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

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

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

Definition at line 36 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);
}

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

meshCentroidCalculator()

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

Definition at line 309 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;
}

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

nodalQuadraturePointToNodeMap()

std::vector< unsigned int > MooseMeshUtils::nodalQuadraturePointToNodeMap	(	const Elem &	elem,
		const std::vector< Point > &	q_points
	)

Match the points of a nodal quadrature rule (e.g.

QNodal on a side of a parent element) to the nodes of an element at the same physical locations. The quadrature ordering is not guaranteed to match the node ordering of the element, especially for higher-order faces, so the association is built geometrically so each quadrature value is attached to the node at the same physical point.

Parameters

elem	the element whose nodes are matched
q_points	the physical locations of the nodal quadrature points

Returns

a map from each quadrature point index to the local index of the matching node

Definition at line 1561 of file MooseMeshUtils.C.

{
  const auto n_nodes = elem.n_nodes();
  if (q_points.size() != n_nodes)
    mooseError("Nodal quadrature produced ",
               q_points.size(),
               " points for element ",
               elem.id(),
               " of type ",
               libMesh::Utility::enum_to_string<ElemType>(elem.type()),
               ", but the element has ",
               n_nodes,
               " nodes.");
 
  const auto invalid_node = std::numeric_limits<unsigned int>::max();
  std::vector<unsigned int> qpoint_to_node(n_nodes, invalid_node);
  std::vector<bool> node_used(n_nodes, false);
 
  const Real element_size = elem.hmax();
  mooseAssert(
      element_size > 0,
      "Element " << elem.id() << " of type "
                 << libMesh::Utility::enum_to_string<ElemType>(elem.type())
                 << " has a non-positive hmax and cannot be used for nodal quadrature point "
                    "matching.");
 
  // The nodal quadrature locations and the generated nodes are two floating-point
  // reconstructions of the same physical points. Scale the tolerance by element size so the
  // matching is insensitive to coordinate magnitude; the 100*TOLERANCE factor allows roundoff
  // from FE reinitialization and mesh generation while remaining far below a valid node spacing.
  const Real matching_tol = 100 * TOLERANCE * element_size;
  const Real matching_tol_sq = matching_tol * matching_tol;
 
  // Each nodal quadrature point should coincide with exactly one still-unused
  // node. The unused-node search makes the mapping one-to-one and
  // avoids silently assigning two quadrature entries to the same node.
  for (const auto qp : make_range(q_points.size()))
  {
    unsigned int closest_node = invalid_node;
    Real closest_dist_sq = std::numeric_limits<Real>::max();
    Real second_closest_dist_sq = std::numeric_limits<Real>::max();
 
    for (const auto n : make_range(n_nodes))
    {
      if (node_used[n])
        continue;
 
      const Real dist_sq = (q_points[qp] - elem.point(n)).norm_sq();
      if (dist_sq < closest_dist_sq)
      {
        second_closest_dist_sq = closest_dist_sq;
        closest_dist_sq = dist_sq;
        closest_node = n;
      }
      else if (dist_sq < second_closest_dist_sq)
        second_closest_dist_sq = dist_sq;
    }
 
    if (closest_node == invalid_node || closest_dist_sq > matching_tol_sq)
      mooseError("Could not match nodal quadrature point ",
                 qp,
                 " at ",
                 q_points[qp],
                 " to a node on element ",
                 elem.id(),
                 " of type ",
                 libMesh::Utility::enum_to_string<ElemType>(elem.type()),
                 ". The nearest unmatched node distance is ",
                 std::sqrt(closest_dist_sq),
                 ", which exceeds the tolerance ",
                 matching_tol,
                 ".");
 
    if (second_closest_dist_sq <= matching_tol_sq)
      mooseError("Nodal quadrature point ",
                 qp,
                 " at ",
                 q_points[qp],
                 " does not map uniquely to element ",
                 elem.id(),
                 " of type ",
                 libMesh::Utility::enum_to_string<ElemType>(elem.type()),
                 ". Two unmatched nodes are within the matching tolerance ",
                 matching_tol,
                 ".");
 
    qpoint_to_node[qp] = closest_node;
    node_used[closest_node] = true;
  }
 
#ifdef DEBUG
  // In optimized builds the mapping above skips already matched nodes for speed. In debug builds,
  // audit the full candidate set to catch ambiguous geometry or accidental many-to-one matches.
  std::vector<unsigned int> node_to_qpoint(n_nodes, invalid_node);
  for (const auto qp : make_range(q_points.size()))
  {
    const auto mapped_node = qpoint_to_node[qp];
    mooseAssert(mapped_node != invalid_node && mapped_node < n_nodes,
                "Invalid node mapping for nodal quadrature point " << qp << ".");
    mooseAssert(node_to_qpoint[mapped_node] == invalid_node,
                "Node " << mapped_node << " on element " << elem.id()
                        << " was matched to both nodal quadrature point "
                        << node_to_qpoint[mapped_node] << " and " << qp << ".");
    node_to_qpoint[mapped_node] = qp;
 
    // Check the qp -> node direction without excluding nodes already matched by previous qps.
    unsigned int candidate_count = 0;
    unsigned int candidate_node = invalid_node;
    for (const auto n : make_range(n_nodes))
      if ((q_points[qp] - elem.point(n)).norm_sq() <= matching_tol_sq)
      {
        ++candidate_count;
        candidate_node = n;
      }
 
    mooseAssert(candidate_count == 1,
                "Nodal quadrature point " << qp << " on element " << elem.id() << " has "
                                          << candidate_count << " node candidates within tolerance "
                                          << matching_tol << ".");
    mooseAssert(candidate_node == mapped_node,
                "Nodal quadrature point "
                    << qp << " on element " << elem.id() << " was matched to node " << mapped_node
                    << ", but the full candidate search found node " << candidate_node << ".");
  }
 
  for (const auto n : make_range(n_nodes))
  {
    mooseAssert(node_to_qpoint[n] != invalid_node,
                "Node " << n << " on element " << elem.id()
                        << " was not matched to a nodal quadrature point.");
 
    // Check the node -> qp direction so every node is also uniquely represented.
    unsigned int candidate_count = 0;
    unsigned int candidate_qp = invalid_node;
    for (const auto qp : make_range(q_points.size()))
      if ((q_points[qp] - elem.point(n)).norm_sq() <= matching_tol_sq)
      {
        ++candidate_count;
        candidate_qp = qp;
      }
 
    mooseAssert(candidate_count == 1,
                "Node " << n << " on element " << elem.id() << " has " << candidate_count
                        << " nodal quadrature point candidates within tolerance " << matching_tol
                        << ".");
    mooseAssert(candidate_qp == node_to_qpoint[n],
                "Node " << n << " on element " << elem.id()
                        << " was matched to nodal quadrature point " << node_to_qpoint[n]
                        << ", but the full candidate search found point " << candidate_qp << ".");
  }
#endif
 
  return qpoint_to_node;
}

Referenced by AutomaticMortarGeneration::computeADNodalNormals(), AutomaticMortarGeneration::computeNodalGeometry(), and AdvancedExtruderGenerator::computeNodeNormals().

swapNodesInElem()

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

Definition at line 699 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);
}

Referenced by AdvancedExtruderGenerator::generate().