for (auto & boundary_name : boundary_names)
    {
      // check that the boundary exists in the mesh
      if (!MooseMeshUtils::hasBoundaryNameOrID(*mesh, boundary_name))
        paramError("boundaries", "The boundary '", boundary_name, "' was not found in the mesh");

      breaking_boundary_ids.insert(boundary_info.get_id_by_name(boundary_name));

  // Check if the input mesh has the given boundaries
  for (const auto & bd : _input_mesh_circular_boundaries)
  {
    if (!MooseMeshUtils::hasBoundaryNameOrID(*input_mesh, bd))
      paramError("input_mesh_circular_boundaries",
                 "the boundary '" + bd + "' does not exist in the input mesh.");
  }

  if (!_cut_face_name.empty())
  {
    if (MooseMeshUtils::hasBoundaryNameOrID(mesh, _cut_face_name))
    {
      const boundary_id_type exist_cut_face_id =
          MooseMeshUtils::getBoundaryID(_cut_face_name, mesh);

  // check that specified boundary is valid, convert BoundaryNames to BoundaryIDs, and sort
  for (const auto & boundary_name : _watertight_boundary_names)
  {
    if (!MooseMeshUtils::hasBoundaryNameOrID(*mesh, boundary_name))
      mooseError("User specified boundary_to_check \'", boundary_name, "\' does not exist");
  }
  _watertight_boundaries = MooseMeshUtils::getBoundaryIDs(*mesh, _watertight_boundary_names, false);

    {
      const auto & boundary_names = getParam<std::vector<BoundaryName>>("from_boundaries");
      for (const auto & bn : boundary_names)
        if (!MooseMeshUtils::hasBoundaryNameOrID(from_moose_mesh.getMesh(), bn))
          paramError("from_boundaries", "The boundary '", bn, "' was not found in the mesh");

      if (!boundary_names.empty())

    {
      const auto & boundary_names = getParam<std::vector<BoundaryName>>("to_boundaries");
      for (const auto & bn : boundary_names)
        if (!MooseMeshUtils::hasBoundaryNameOrID(to_moose_mesh.getMesh(), bn))
          paramError("to_boundaries", "The boundary '", bn, "' was not found in the mesh");

      if (!boundary_names.empty())

    if (_from_meshes.size())
    {
      const auto & sb = getParam<BoundaryName>("source_boundary");
      if (!MooseMeshUtils::hasBoundaryNameOrID(_from_meshes[0]->getMesh(), sb))
        paramError("source_boundary", "The boundary '", sb, "' was not found in the mesh");

      bboxes = getFromBoundingBoxes(_from_meshes[0]->getBoundaryID(sb));

  {
    const auto & sb = getParam<BoundaryName>("source_boundary");
    BoundaryID src_bnd_id = mesh->getBoundaryID(sb);
    if (!MooseMeshUtils::hasBoundaryNameOrID(mesh_base, sb))
      paramError("source_boundary", "The boundary '", sb, "' was not found in the mesh");

    if (is_nodal)

    const std::vector<BoundaryName> & target_boundaries =
        getParam<std::vector<BoundaryName>>("target_boundary");
    for (const auto & b : target_boundaries)
      if (!MooseMeshUtils::hasBoundaryNameOrID(to_mesh, b))
        paramError("target_boundary", "The boundary '", b, "' was not found in the mesh");

    ConstBndNodeRange & bnd_nodes = *(_to_meshes[to_problem_id])->getBoundaryNodeRange();

            const std::vector<BoundaryName> & boundary_names =
                getParam<std::vector<BoundaryName>>("boundary");
            for (const auto & b : boundary_names)
              if (!MooseMeshUtils::hasBoundaryNameOrID(*mesh, b))
                paramError("boundary", "The boundary '", b, "' was not found in the mesh");

            std::vector<BoundaryID> ids = mesh->getBoundaryIDs(boundary_names, true);

        const std::vector<BoundaryName> & boundary_names =
            getParam<std::vector<BoundaryName>>("boundary");
        for (const auto & b : boundary_names)
          if (!MooseMeshUtils::hasBoundaryNameOrID(*to_mesh, b))
            paramError("boundary", "The boundary '", b, "' was not found in the mesh");

        std::vector<BoundaryID> ids = to_mesh->getBoundaryIDs(boundary_names, true);

  std::vector<boundary_id_type> boundary_ids;
  for (const auto & sideset : boundary_names)
  {
    if (!MooseMeshUtils::hasBoundaryNameOrID(mesh, sideset))
      throw MooseException("The provided boundary '", sideset, "' was not found within the mesh");
    boundary_ids.push_back(MooseMeshUtils::getBoundaryID(sideset, mesh));
    MooseMeshUtils::changeBoundaryId(mesh, boundary_ids.back(), uniform_tmp_bid, false);

}

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

bool
hasBoundaryNameOrID(const MeshBase & mesh, const BoundaryName & name_or_id)
{
  const auto id = getBoundaryID(name_or_id, mesh);
  return hasBoundaryID(mesh, id);
}

void

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