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. More...
void	changeBoundaryId (MeshBase &mesh, const libMesh::boundary_id_type old_id, const libMesh::boundary_id_type new_id, bool delete_prev)
	Changes the old boundary ID to a new ID in the mesh. More...
void	changeSubdomainId (MeshBase &mesh, const subdomain_id_type old_id, const subdomain_id_type new_id)
	Changes the old subdomain ID to a new ID in the mesh. More...
std::vector< BoundaryID >	getBoundaryIDs (const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown, const std::set< BoundaryID > &mesh_boundary_ids)
	Gets the boundary IDs with their names. More...
std::vector< BoundaryID >	getBoundaryIDs (const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown)
	Gets the boundary IDs with their names. More...
std::set< BoundaryID >	getBoundaryIDSet (const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown)
	Gets the boundary IDs into a set with their names. More...
BoundaryID	getBoundaryID (const BoundaryName &boundary_name, const MeshBase &mesh)
	Gets the boundary ID associated with the given BoundaryName. More...
SubdomainID	getSubdomainID (const SubdomainName &subdomain_name, const MeshBase &mesh)
	Gets the subdomain ID associated with the given SubdomainName. More...
std::vector< subdomain_id_type >	getSubdomainIDs (const libMesh::MeshBase &mesh, const std::vector< SubdomainName > &subdomain_name)
	Get the associated subdomainIDs for the subdomain names that are passed in. More...
std::set< subdomain_id_type >	getSubdomainIDs (const libMesh::MeshBase &mesh, const std::set< SubdomainName > &subdomain_name)
Point	meshCentroidCalculator (const MeshBase &mesh)
	Calculates the centroid of a MeshBase. More...
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 factor More...
template<typename P , typename C >
C	computeDistanceToAxis (const P &point, const Point &origin, const RealVectorValue &direction)
	Computes the distance to a general axis. More...
template<typename P , typename C >
void	coordTransformFactorRZGeneral (const P &point, const std::pair< Point, RealVectorValue > &axis, C &factor)
	Computes a coordinate transformation factor for a general axisymmetric axis. More...
void	computeFiniteVolumeCoords (FaceInfo &fi, const Moose::CoordinateSystemType coord_type, const unsigned int rz_radial_coord=libMesh::invalid_uint)
std::unordered_map< dof_id_type, dof_id_type >	getExtraIDUniqueCombinationMap (const MeshBase &mesh, const std::set< SubdomainID > &block_ids, std::vector< ExtraElementIDName > extra_ids)
	Crate a new set of element-wise IDs by finding unique combinations of existing extra ID values. More...
bool	isCoPlanar (const std::vector< Point > vec_pts, const Point plane_nvec, const Point fixed_pt)
	Decides whether all the Points of a vector of Points are in a plane that is defined by a normal vector and an inplane Point. More...
bool	isCoPlanar (const std::vector< Point > vec_pts, const Point plane_nvec)
	Decides whether all the Points of a vector of Points are in a plane with a given normal vector. More...
bool	isCoPlanar (const std::vector< Point > vec_pts)
	Decides whether all the Points of a vector of Points are coplanar. More...
SubdomainID	getNextFreeSubdomainID (MeshBase &input_mesh)
	Checks input mesh and returns max(block ID) + 1, which represents a block ID that is not currently in use in the mesh. More...
BoundaryID	getNextFreeBoundaryID (MeshBase &input_mesh)
	Checks input mesh and returns the largest boundary ID in the mesh plus one, which is a boundary ID in the mesh that is not currently in use. More...
bool	hasSubdomainID (const MeshBase &input_mesh, const SubdomainID &id)
	Whether a particular subdomain ID exists in the mesh. More...
bool	hasSubdomainName (const MeshBase &input_mesh, const SubdomainName &name)
	Whether a particular subdomain name exists in the mesh. More...
bool	hasBoundaryID (const MeshBase &input_mesh, const BoundaryID id)
	Whether a particular boundary ID exists in the mesh. More...
bool	hasBoundaryName (const MeshBase &input_mesh, const BoundaryName &name)
	Whether a particular boundary name exists in the mesh. More...
void	makeOrderedNodeList (std::vector< std::pair< dof_id_type, dof_id_type >> &node_assm, std::vector< dof_id_type > &elem_id_list, std::vector< dof_id_type > &midpoint_node_list, std::vector< dof_id_type > &ordered_node_list, std::vector< dof_id_type > &ordered_elem_id_list)
	Convert a list of sides in the form of a vector of pairs of node ids into a list of ordered nodes based on connectivity. More...
void	makeOrderedNodeList (std::vector< std::pair< dof_id_type, dof_id_type >> &node_assm, std::vector< dof_id_type > &elem_id_list, std::vector< dof_id_type > &ordered_node_list, std::vector< dof_id_type > &ordered_elem_id_list)
	Convert a list of sides in the form of a vector of pairs of node ids into a list of ordered nodes based on connectivity. More...
template<typename T , typename Q >
Q	getIDFromName (const T &name)
	Converts a given name (BoundaryName or SubdomainName) that is known to only contain digits into a corresponding ID (BoundaryID or SubdomainID) and performs bounds checking to ensure that overflow doesn't happen. More...
void	swapNodesInElem (Elem &elem, const unsigned int nd1, const unsigned int nd2)
	Swap two nodes within an element. More...
template<typename T >
void	idSwapParametersProcessor (const std::string &class_name, const std::string &id_name, const std::vector< std::vector< T >> &id_swaps, std::vector< std::unordered_map< T, T >> &id_swap_pairs, const unsigned int row_index_shift=0)
	Reprocess the swap related input parameters to make pairs out of them to ease further processing. More...
void	extraElemIntegerSwapParametersProcessor (const std::string &class_name, const unsigned int num_sections, const unsigned int num_integers, const std::vector< std::vector< std::vector< dof_id_type >>> &elem_integers_swaps, std::vector< std::unordered_map< dof_id_type, dof_id_type >> &elem_integers_swap_pairs)
	Reprocess the elem_integers_swaps into maps so they are easier to use. More...
std::unique_ptr< ReplicatedMesh >	buildBoundaryMesh (const ReplicatedMesh &input_mesh, const boundary_id_type boundary_id)
	Build a lower-dimensional mesh from a boundary of an input mesh Note: The lower-dimensional mesh will only have one subdomain and one boundary. More...
void	createSubdomainFromSidesets (std::unique_ptr< MeshBase > &mesh, std::vector< BoundaryName > boundary_names, const SubdomainID new_subdomain_id, const SubdomainName new_subdomain_name, const std::string type_name)
	Create a new subdomain by generating new side elements from a list of sidesets in a given mesh. More...
void	convertBlockToMesh (std::unique_ptr< MeshBase > &source_mesh, std::unique_ptr< MeshBase > &target_mesh, const std::vector< SubdomainName > &target_blocks)
	Convert a list of blocks in a given mesh to a standalone new mesh. More...
void	mergeBoundaryIDsWithSameName (MeshBase &mesh)
void	changeBoundaryId (MeshBase &mesh, const boundary_id_type old_id, const boundary_id_type new_id, bool delete_prev)
BoundaryID	getBoundaryID (const BoundaryName &boundary_name, const MeshBase &mesh)
SubdomainID	getSubdomainID (const SubdomainName &subdomain_name, const MeshBase &mesh)
void	changeSubdomainId (MeshBase &mesh, const subdomain_id_type old_id, const subdomain_id_type new_id)
Point	meshCentroidCalculator (const MeshBase &mesh)
std::unordered_map< dof_id_type, dof_id_type >	getExtraIDUniqueCombinationMap (const MeshBase &mesh, const std::set< SubdomainID > &block_ids, std::vector< ExtraElementIDName > extra_ids)
bool	isCoPlanar (const std::vector< Point > vec_pts, const Point plane_nvec, const Point fixed_pt)
bool	isCoPlanar (const std::vector< Point > vec_pts, const Point plane_nvec)
bool	isCoPlanar (const std::vector< Point > vec_pts)
SubdomainID	getNextFreeSubdomainID (MeshBase &input_mesh)
BoundaryID	getNextFreeBoundaryID (MeshBase &input_mesh)
bool	hasSubdomainID (const MeshBase &input_mesh, const SubdomainID &id)
bool	hasSubdomainName (const MeshBase &input_mesh, const SubdomainName &name)
bool	hasBoundaryID (const MeshBase &input_mesh, const BoundaryID id)
bool	hasBoundaryName (const MeshBase &input_mesh, const BoundaryName &name)
void	swapNodesInElem (Elem &elem, const unsigned int nd1, const unsigned int nd2)
std::unique_ptr< ReplicatedMesh >	buildBoundaryMesh (const ReplicatedMesh &input_mesh, const boundary_id_type boundary_id)
void	createSubdomainFromSidesets (std::unique_ptr< MeshBase > &mesh, std::vector< BoundaryName > boundary_names, const SubdomainID new_subdomain_id, const SubdomainName new_subdomain_name, const std::string type_name)
void	convertBlockToMesh (std::unique_ptr< MeshBase > &source_mesh, std::unique_ptr< MeshBase > &target_mesh, const std::vector< SubdomainName > &target_blocks)

Function Documentation

buildBoundaryMesh() [1/2]

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

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

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

Parameters

input_mesh	The input mesh
boundary_id	The boundary id

buildBoundaryMesh() [2/2]

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

Definition at line 611 of file MooseMeshUtils.C.

{
  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 & bside : side_list)
  {
    if (std::get<2>(bside) != boundary_id)
      continue;

    const Elem * elem = input_mesh.elem_ptr(std::get<0>(bside));
    const auto side = std::get<1>(bside);
    auto side_elem = elem->build_side_ptr(side);
    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 does not have a boundary with id ", boundary_id);

  return poly_mesh;
}

changeBoundaryId() [1/2]

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

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

Parameters

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

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

changeBoundaryId() [2/2]

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

Definition at line 62 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.set_isnt_prepared();
}

changeSubdomainId() [1/2]

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

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

Parameters

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

changeSubdomainId() [2/2]

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

Definition at line 266 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.set_isnt_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 184 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 207 of file MooseMeshUtils.h.

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

convertBlockToMesh() [1/2]

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

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

Parameters

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

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

convertBlockToMesh() [2/2]

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

Definition at line 801 of file MooseMeshUtils.C.

{
  if (!source_mesh->is_replicated())
    mooseError("This generator does not support distributed meshes.");

  const auto target_block_ids = MooseMeshUtils::getSubdomainIDs(*source_mesh, target_blocks);

  // Check that the block ids/names exist in the mesh
  std::set<SubdomainID> mesh_blocks;
  source_mesh->subdomain_ids(mesh_blocks);

  for (const auto i : index_range(target_block_ids))
    if (target_block_ids[i] == Moose::INVALID_BLOCK_ID || !mesh_blocks.count(target_block_ids[i]))
    {
      mooseException("The target_block '", target_blocks[i], "' was not found within the mesh.");
    }

  // know which nodes have already been inserted, by tracking the old mesh's node's ids'
  std::unordered_map<dof_id_type, dof_id_type> old_new_node_map;

  for (const auto target_block_id : target_block_ids)
  {

    for (auto elem : source_mesh->active_subdomain_elements_ptr_range(target_block_id))
    {
      if (elem->level() != 0)
        mooseError("Refined blocks are not supported by this generator. "
                   "Can you re-organize mesh generators to refine after converting the block?");

      // make a deep copy so that mutiple meshes' destructors don't segfault at program termination
      auto copy = elem->build(elem->type());

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

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

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

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

coordTransformFactorRZGeneral()

template<typename P , typename C >

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

Computes a coordinate transformation factor for a general axisymmetric axis.

Parameters

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

Definition at line 199 of file MooseMeshUtils.h.

Referenced by coordTransformFactor().

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

createSubdomainFromSidesets() [1/2]

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

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

Parameters

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

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

createSubdomainFromSidesets() [2/2]

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

Definition at line 652 of file MooseMeshUtils.C.

{
  // Generate a new block id if one isn't supplied.
  SubdomainID new_block_id = new_subdomain_id;

  // Make sure our boundary info and parallel counts are setup
  if (!mesh->is_prepared())
  {
    const bool allow_remote_element_removal = mesh->allow_remote_element_removal();
    // We want all of our boundary elements available, so avoid removing them if they haven't
    // already been so
    mesh->allow_remote_element_removal(false);
    mesh->prepare_for_use();
    mesh->allow_remote_element_removal(allow_remote_element_removal);
  }

  // Check that the sidesets are present in the mesh
  for (const auto & sideset : boundary_names)
    if (!MooseMeshUtils::hasBoundaryName(*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.get(), 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.get(), elem_action_functor);

    // now that we've gathered everything, we need to rebuild the side list
    side_list = mesh->get_boundary_info().build_side_list();
  }

  std::vector<std::pair<dof_id_type, ElemSidePair>> element_sides_on_boundary;
  dof_id_type counter = 0;
  for (const auto & triple : side_list)
    if (sidesets.count(std::get<2>(triple)))
    {
      if (auto elem = mesh->query_elem_ptr(std::get<0>(triple)))
      {
        if (!elem->active())
          mooseError(
              "Only active, level 0 elements can be made interior parents of new level 0 lower-d "
              "elements. Make sure that ",
              type_name,
              "s are run before any refinement generators");
        element_sides_on_boundary.push_back(
            std::make_pair(counter, ElemSidePair(elem, std::get<1>(triple))));
      }
      ++counter;
    }

  dof_id_type max_elem_id = mesh->max_elem_id();
  unique_id_type max_unique_id = mesh->parallel_max_unique_id();

  // Making an important assumption that at least our boundary elements are the same on all
  // processes even in distributed mesh mode (this is reliant on the correct ghosting functors
  // existing on the mesh)
  for (auto & [i, elem_side] : element_sides_on_boundary)
  {
    Elem * elem = elem_side.elem;

    const auto side = elem_side.side;

    // Build a non-proxy element from this side.
    std::unique_ptr<Elem> side_elem(elem->build_side_ptr(side));

    // The side will be added with the same processor id as the parent.
    side_elem->processor_id() = elem->processor_id();

    // Add subdomain ID
    side_elem->subdomain_id() = new_block_id;

    // Also assign the side's interior parent, so it is always
    // easy to figure out the Elem we came from.
    side_elem->set_interior_parent(elem);

    // Add id
    side_elem->set_id(max_elem_id + i);
    side_elem->set_unique_id(max_unique_id + i);

    // Finally, add the lower-dimensional element to the mesh->
    mesh->add_elem(side_elem.release());
  };

  // Assign block name, if provided
  if (new_subdomain_name.size())
    mesh->subdomain_name(new_block_id) = new_subdomain_name;

  const bool skip_partitioning_old = mesh->skip_partitioning();
  mesh->skip_partitioning(true);
  mesh->prepare_for_use();
  mesh->skip_partitioning(skip_partitioning_old);
}

extraElemIntegerSwapParametersProcessor()

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

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

Parameters

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

Definition at line 579 of file MooseMeshUtils.C.

Referenced by AdvancedExtruderGenerator::AdvancedExtruderGenerator().

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

    elem_integers_swap_pairs.insert(elem_integers_swap_pairs.end(),
                                    elem_integer_swap_pairs.begin(),
                                    elem_integer_swap_pairs.end());
  }
}

getBoundaryID() [1/2]

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

Gets the boundary ID associated with the given BoundaryName.

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

Referenced by MultiAppNearestNodeTransfer::execute(), BoundaryDeletionGenerator::generate(), RenameBoundaryGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), XYDelaunayGenerator::generate(), MooseMesh::getBoundaryID(), and MooseMeshElementConversionUtils::transitionLayerGenerator().

getBoundaryID() [2/2]

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

Definition at line 233 of file MooseMeshUtils.C.

Referenced by hasBoundaryName().

{
  BoundaryID id = Moose::INVALID_BOUNDARY_ID;
  if (boundary_name.empty())
    return id;

  if (!MooseUtils::isDigits(boundary_name))
    id = mesh.get_boundary_info().get_id_by_name(boundary_name);
  else
    id = getIDFromName<BoundaryName, BoundaryID>(boundary_name);

  return id;
}

getBoundaryIDs() [1/2]

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

Gets the boundary IDs with their names.

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

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

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

Referenced by BoundaryPreservedMarker::BoundaryPreservedMarker(), MeshExtruderGenerator::changeID(), SubProblem::checkBoundaryMatProps(), createSubdomainFromSidesets(), Boundary2DDelaunayGenerator::General2DDelaunay(), BoundaryLayerSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), FillBetweenSidesetsGenerator::generate(), SideSetsFromNormalsGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), PolyLineMeshGenerator::generate(), RefineSidesetGenerator::generate(), SideSetsBetweenSubdomainsGenerator::generate(), SideSetsFromPointsGenerator::generate(), MeshDiagnosticsGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), StackGenerator::generate(), ParsedGenerateNodeset::generate(), AdvancedExtruderGenerator::generate(), XYDelaunayGenerator::generate(), ElementDeletionGeneratorBase::generate(), ParsedGenerateSideset::generate(), SideSetsAroundSubdomainGenerator::generate(), PatternedMeshGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), getBoundaryIDs(), MooseMesh::getBoundaryIDs(), getBoundaryIDSet(), NodeSetsGeneratorBase::setup(), and SideSetsGeneratorBase::setup().

{
  const BoundaryInfo & boundary_info = mesh.get_boundary_info();
  const std::map<BoundaryID, std::string> & sideset_map = boundary_info.get_sideset_name_map();
  const std::map<BoundaryID, std::string> & nodeset_map = boundary_info.get_nodeset_name_map();

  BoundaryID max_boundary_local_id = 0;
  /* It is required to generate a new ID for a given name. It is used often in mesh modifiers such
   * as SideSetsBetweenSubdomains. Then we need to check the current boundary ids since they are
   * changing during "mesh modify()", and figure out the right max boundary ID. Most of mesh
   * modifiers are running in serial, and we won't involve a global communication.
   */
  if (generate_unknown)
  {
    const auto & bids = mesh.is_prepared() ? mesh.get_boundary_info().get_global_boundary_ids()
                                           : mesh.get_boundary_info().get_boundary_ids();
    max_boundary_local_id = bids.empty() ? 0 : *(bids.rbegin());
    /* We should not hit this often */
    if (!mesh.is_prepared() && !mesh.is_serial())
      mesh.comm().max(max_boundary_local_id);
  }

  BoundaryID max_boundary_id = mesh_boundary_ids.empty() ? 0 : *(mesh_boundary_ids.rbegin());

  max_boundary_id =
      max_boundary_id > max_boundary_local_id ? max_boundary_id : max_boundary_local_id;

  std::vector<BoundaryID> ids(boundary_name.size());
  for (const auto i : index_range(boundary_name))
  {
    if (boundary_name[i] == "ANY_BOUNDARY_ID")
    {
      ids.assign(mesh_boundary_ids.begin(), mesh_boundary_ids.end());
      if (i)
        mooseWarning("You passed \"ANY_BOUNDARY_ID\" in addition to other boundary_names.  This "
                     "may be a logic error.");
      break;
    }

    if (boundary_name[i].empty() && !generate_unknown)
      mooseError("Incoming boundary name is empty and we are not generating unknown boundary IDs. "
                 "This is invalid.");

    BoundaryID id;

    if (boundary_name[i].empty() || !MooseUtils::isDigits(boundary_name[i]))
    {
      if (generate_unknown &&
          !MooseUtils::doesMapContainValue(sideset_map, std::string(boundary_name[i])) &&
          !MooseUtils::doesMapContainValue(nodeset_map, std::string(boundary_name[i])))
        id = ++max_boundary_id;
      else
        id = boundary_info.get_id_by_name(boundary_name[i]);
    }
    else
      id = getIDFromName<BoundaryName, BoundaryID>(boundary_name[i]);

    ids[i] = id;
  }

  return ids;
}

getBoundaryIDs() [2/2]

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

Gets the boundary IDs with their names.

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

Definition at line 106 of file MooseMeshUtils.C.

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

getBoundaryIDSet()

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

Gets the boundary IDs into a set with their names.

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

Definition at line 187 of file MooseMeshUtils.C.

Referenced by DomainUserObject::DomainUserObject().

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

getExtraIDUniqueCombinationMap() [1/2]

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

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

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

Parameters

mesh	input mesh
block_ids	block ids
extra_ids	extra ids

Returns

map of element id to new extra id

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

getExtraIDUniqueCombinationMap() [2/2]

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

Definition at line 295 of file MooseMeshUtils.C.

{
  // check block restriction
  const bool block_restricted = !block_ids.empty();
  // get element id name of interest in recursive parsing algorithm
  ExtraElementIDName id_name = extra_ids.back();
  extra_ids.pop_back();
  const auto id_index = mesh.get_elem_integer_index(id_name);

  // create base parsed id set
  if (extra_ids.empty())
  {
    // get set of extra id values;
    std::vector<dof_id_type> ids;
    {
      std::set<dof_id_type> ids_set;
      for (const auto & elem : mesh.active_element_ptr_range())
      {
        if (block_restricted && block_ids.find(elem->subdomain_id()) == block_ids.end())
          continue;
        const auto id = elem->get_extra_integer(id_index);
        ids_set.insert(id);
      }
      mesh.comm().set_union(ids_set);
      ids.assign(ids_set.begin(), ids_set.end());
    }

    // determine new extra id values;
    std::unordered_map<dof_id_type, dof_id_type> parsed_ids;
    for (auto & elem : mesh.active_element_ptr_range())
    {
      if (block_restricted && block_ids.find(elem->subdomain_id()) == block_ids.end())
        continue;
      parsed_ids[elem->id()] = std::distance(
          ids.begin(), std::lower_bound(ids.begin(), ids.end(), elem->get_extra_integer(id_index)));
    }
    return parsed_ids;
  }

  // if extra_ids is not empty, recursively call getExtraIDUniqueCombinationMap
  const auto base_parsed_ids =
      MooseMeshUtils::getExtraIDUniqueCombinationMap(mesh, block_ids, extra_ids);
  // parsing extra ids based on ref_parsed_ids
  std::vector<std::pair<dof_id_type, dof_id_type>> unique_ids;
  {
    std::set<std::pair<dof_id_type, dof_id_type>> unique_ids_set;
    for (const auto & elem : mesh.active_element_ptr_range())
    {
      if (block_restricted && block_ids.find(elem->subdomain_id()) == block_ids.end())
        continue;
      const dof_id_type id1 = libmesh_map_find(base_parsed_ids, elem->id());
      const dof_id_type id2 = elem->get_extra_integer(id_index);
      const std::pair<dof_id_type, dof_id_type> ids = std::make_pair(id1, id2);
      unique_ids_set.insert(ids);
    }
    mesh.comm().set_union(unique_ids_set);
    unique_ids.assign(unique_ids_set.begin(), unique_ids_set.end());
  }

  std::unordered_map<dof_id_type, dof_id_type> parsed_ids;

  for (const auto & elem : mesh.active_element_ptr_range())
  {
    if (block_restricted && block_ids.find(elem->subdomain_id()) == block_ids.end())
      continue;
    const dof_id_type id1 = libmesh_map_find(base_parsed_ids, elem->id());
    const dof_id_type id2 = elem->get_extra_integer(id_index);
    const dof_id_type new_id = std::distance(
        unique_ids.begin(),
        std::lower_bound(unique_ids.begin(), unique_ids.end(), std::make_pair(id1, id2)));
    parsed_ids[elem->id()] = new_id;
  }

  return parsed_ids;
}

getIDFromName()

template<typename T , typename Q >

Q MooseMeshUtils::getIDFromName

(

const T &

name

)

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

Parameters

name	Name that is to be converted into an ID.

Returns

ID type corresponding to the type of name.

Definition at line 338 of file MooseMeshUtils.h.

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

  return id_Q;
}

getNextFreeBoundaryID() [1/2]

BoundaryID MooseMeshUtils::getNextFreeBoundaryID

(

MeshBase &

input_mesh

)

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

Parameters

input

mesh over which to compute the next free boundary ID

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

getNextFreeBoundaryID() [2/2]

BoundaryID MooseMeshUtils::getNextFreeBoundaryID

(

MeshBase &

input_mesh

)

Definition at line 436 of file MooseMeshUtils.C.

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

getNextFreeSubdomainID() [1/2]

SubdomainID MooseMeshUtils::getNextFreeSubdomainID

(

MeshBase &

input_mesh

)

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

Parameters

input

mesh over which to compute the next free block id

Referenced by Boundary2DDelaunayGenerator::General2DDelaunay(), LowerDBlockFromSidesetGenerator::generate(), BoundaryLayerSubdomainGenerator::generate(), Boundary2DDelaunayGenerator::generate(), XYZDelaunayGenerator::generate(), XYDelaunayGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), MeshRepairGenerator::separateSubdomainsByElementType(), and MooseMeshElementConversionUtils::transitionLayerGenerator().

getNextFreeSubdomainID() [2/2]

SubdomainID MooseMeshUtils::getNextFreeSubdomainID

(

MeshBase &

input_mesh

)

Definition at line 416 of file MooseMeshUtils.C.

{
  // Call this to get most up to date block id information
  input_mesh.cache_elem_data();

  std::set<SubdomainID> preexisting_subdomain_ids;
  input_mesh.subdomain_ids(preexisting_subdomain_ids);
  if (preexisting_subdomain_ids.empty())
    return 0;
  else
  {
    const auto highest_subdomain_id =
        *std::max_element(preexisting_subdomain_ids.begin(), preexisting_subdomain_ids.end());
    mooseAssert(highest_subdomain_id < std::numeric_limits<SubdomainID>::max(),
                "A SubdomainID with max possible value was found");
    return highest_subdomain_id + 1;
  }
}

getSubdomainID() [1/2]

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

Gets the subdomain ID associated with the given SubdomainName.

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

Referenced by UniqueExtraIDMeshGenerator::generate(), RenameBlockGenerator::generate(), ParsedExtraElementIDGenerator::generate(), XYZDelaunayGenerator::generate(), XYDelaunayGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), MooseMesh::getSubdomainID(), getSubdomainIDs(), MooseMeshXYCuttingUtils::quadToTriOnLine(), and MooseMeshXYCuttingUtils::quasiTriElementsFixer().

getSubdomainID() [2/2]

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

Definition at line 248 of file MooseMeshUtils.C.

Referenced by hasSubdomainName().

{
  if (subdomain_name == "ANY_BLOCK_ID")
    mooseError("getSubdomainID() does not work with \"ANY_BLOCK_ID\"");

  SubdomainID id = Moose::INVALID_BLOCK_ID;
  if (subdomain_name.empty())
    return id;

  if (!MooseUtils::isDigits(subdomain_name))
    id = mesh.get_id_by_name(subdomain_name);
  else
    id = getIDFromName<SubdomainName, SubdomainID>(subdomain_name);

  return id;
}

getSubdomainIDs() [1/2]

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

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

Parameters

mesh	The mesh
subdomain_name	The names of the subdomains

Returns

The subdomain ids from the passed subdomain names.

Definition at line 196 of file MooseMeshUtils.C.

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

{
  std::vector<subdomain_id_type> ids;

  // shortcut for "ANY_BLOCK_ID"
  if (subdomain_names.size() == 1 && subdomain_names[0] == "ANY_BLOCK_ID")
  {
    // since get_mesh_subdomains() requires a prepared mesh, we need to check that here
    mooseAssert(mesh.is_prepared(),
                "getSubdomainIDs() should only be called on a prepared mesh if ANY_BLOCK_ID is "
                "used to query all block IDs");
    ids.assign(mesh.get_mesh_subdomains().begin(), mesh.get_mesh_subdomains().end());
    return ids;
  }

  // loop through subdomain names and get IDs (this preserves the order of subdomain_names)
  ids.resize(subdomain_names.size());
  for (auto i : index_range(subdomain_names))
  {
    if (subdomain_names[i] == "ANY_BLOCK_ID")
      mooseError("getSubdomainIDs() accepts \"ANY_BLOCK_ID\" if and only if it is the only "
                 "subdomain name being queried.");
    ids[i] = MooseMeshUtils::getSubdomainID(subdomain_names[i], mesh);
  }

  return ids;
}

getSubdomainIDs() [2/2]

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

Definition at line 225 of file MooseMeshUtils.C.

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

hasBoundaryID() [1/2]

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

Whether a particular boundary ID exists in the mesh.

Parameters

input	mesh over which to determine boundary IDs
boundary	ID

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

hasBoundaryID() [2/2]

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

Definition at line 466 of file MooseMeshUtils.C.

Referenced by hasBoundaryName().

{
  const BoundaryInfo & boundary_info = input_mesh.get_boundary_info();
  std::set<boundary_id_type> boundary_ids = boundary_info.get_boundary_ids();

  // On a distributed mesh we may have boundary IDs that only exist on
  // other processors
  if (!input_mesh.is_replicated())
    input_mesh.comm().set_union(boundary_ids);

  return boundary_ids.count(id) && (id != Moose::INVALID_BOUNDARY_ID);
}

hasBoundaryName() [1/2]

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

Whether a particular boundary name exists in the mesh.

Parameters

input	mesh over which to determine boundary names
boundary	name

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

hasBoundaryName() [2/2]

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

Definition at line 480 of file MooseMeshUtils.C.

{
  const auto id = getBoundaryID(name, input_mesh);
  return hasBoundaryID(input_mesh, id);
}

hasSubdomainID() [1/2]

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

Whether a particular subdomain ID exists in the mesh.

Parameters

input	mesh over which to determine subdomain IDs
subdomain	ID

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

hasSubdomainID() [2/2]

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

Definition at line 445 of file MooseMeshUtils.C.

Referenced by hasSubdomainName().

{
  std::set<SubdomainID> mesh_blocks;
  input_mesh.subdomain_ids(mesh_blocks);

  // On a distributed mesh we may have sideset IDs that only exist on
  // other processors
  if (!input_mesh.is_replicated())
    input_mesh.comm().set_union(mesh_blocks);

  return mesh_blocks.count(id) && (id != Moose::INVALID_BLOCK_ID);
}

hasSubdomainName() [1/2]

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

Whether a particular subdomain name exists in the mesh.

Parameters

input	mesh over which to determine subdomain names
subdomain	name

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

hasSubdomainName() [2/2]

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

Definition at line 459 of file MooseMeshUtils.C.

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

idSwapParametersProcessor()

template<typename T >

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

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

Parameters

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

Definition at line 375 of file MooseMeshUtils.h.

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

{
  id_swap_pairs.resize(id_swaps.size());
  for (const auto i : index_range(id_swaps))
  {
    const auto & swaps = id_swaps[i];
    auto & swap_pairs = id_swap_pairs[i];

    if (swaps.size() % 2)
      throw MooseException("Row ",
                           row_index_shift + i + 1,
                           " of ",
                           id_name,
                           " in ",
                           class_name,
                           " does not contain an even number of entries! Num entries: ",
                           swaps.size());

    swap_pairs.reserve(swaps.size() / 2);
    for (unsigned int j = 0; j < swaps.size(); j += 2)
      swap_pairs[swaps[j]] = swaps[j + 1];
  }
}

isCoPlanar() [1/6]

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

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

Parameters

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

Returns

whether all the Points are in the given plane

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

isCoPlanar() [2/6]

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

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

Parameters

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

Returns

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

isCoPlanar() [3/6]

bool MooseMeshUtils::isCoPlanar

(

const std::vector< Point >

vec_pts

)

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

Parameters

vec_pts

vector of points to be examined

Returns

whether all the Points are in a same plane

isCoPlanar() [4/6]

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

Definition at line 374 of file MooseMeshUtils.C.

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

isCoPlanar() [5/6]

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

Definition at line 383 of file MooseMeshUtils.C.

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

isCoPlanar() [6/6]

bool MooseMeshUtils::isCoPlanar

(

const std::vector< Point >

vec_pts

)

Definition at line 389 of file MooseMeshUtils.C.

Referenced by isCoPlanar().

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

makeOrderedNodeList() [1/2]

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

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

Parameters

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

Definition at line 487 of file MooseMeshUtils.C.

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

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

      // mark the first flip event.
      is_flipped = true;
      std::reverse(ordered_node_list.begin(), ordered_node_list.end());
      std::reverse(midpoint_node_list.begin(), midpoint_node_list.end());
      std::reverse(ordered_elem_id_list.begin(), ordered_elem_id_list.end());
      // As this iteration is wasted, set the iterator backward
      i--;
    }
  }
}

makeOrderedNodeList() [2/2]

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

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

Parameters

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

Definition at line 560 of file MooseMeshUtils.C.

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

mergeBoundaryIDsWithSameName() [1/2]

void MooseMeshUtils::mergeBoundaryIDsWithSameName

(

MeshBase &

mesh

)

Definition at line 35 of file MooseMeshUtils.C.

{
  // We check if we have the same boundary name with different IDs. If we do, we assign the
  // first ID to every occurrence.
  const auto & side_bd_name_map = mesh.get_boundary_info().get_sideset_name_map();
  const auto & node_bd_name_map = mesh.get_boundary_info().get_nodeset_name_map();
  std::map<boundary_id_type, boundary_id_type> same_name_ids;

  auto populate_map = [](const std::map<boundary_id_type, std::string> & map,
                         std::map<boundary_id_type, boundary_id_type> & same_ids)
  {
    for (const auto & pair_outer : map)
      for (const auto & pair_inner : map)
        // The last condition is needed to make sure we only store one combination
        if (pair_outer.second == pair_inner.second && pair_outer.first != pair_inner.first &&
            same_ids.find(pair_inner.first) == same_ids.end())
          same_ids[pair_outer.first] = pair_inner.first;
  };

  populate_map(side_bd_name_map, same_name_ids);
  populate_map(node_bd_name_map, same_name_ids);

  for (const auto & [id1, id2] : same_name_ids)
    mesh.get_boundary_info().renumber_id(id2, id1);
}

mergeBoundaryIDsWithSameName() [2/2]

void MooseMeshUtils::mergeBoundaryIDsWithSameName

(

MeshBase &

mesh

)

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

Parameters

mesh	The input mesh whose boundaries we will modify

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

meshCentroidCalculator() [1/2]

Point MooseMeshUtils::meshCentroidCalculator

(

const MeshBase &

mesh

)

Calculates the centroid of a MeshBase.

Parameters

mesh	input mesh whose centroid needs to be calculated

Returns

a Point data containing the mesh centroid

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

meshCentroidCalculator() [2/2]

Point MooseMeshUtils::meshCentroidCalculator

(

const MeshBase &

mesh

)

Definition at line 277 of file MooseMeshUtils.C.

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

swapNodesInElem() [1/2]

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

Swap two nodes within an element.

Parameters

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

Referenced by AdvancedExtruderGenerator::generate().

swapNodesInElem() [2/2]

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

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