MooseMeshUtils Namespace Reference

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

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 584 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(), and FillBetweenSidesetsGenerator::generate().

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 52 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 239 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 174 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 197 of file MooseMeshUtils.h.

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

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

Referenced by coordTransformFactor().

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

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 552 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(), XYDelaunayGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), and MooseMesh::getBoundaryID().

getBoundaryID() [2/2]

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

Definition at line 206 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 105 of file MooseMeshUtils.C.

Referenced by BoundaryPreservedMarker::BoundaryPreservedMarker(), MeshExtruderGenerator::changeID(), SubProblem::checkBoundaryMatProps(), BoundaryLayerSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), FillBetweenSidesetsGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), SideSetsFromNormalsGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), PolyLineMeshGenerator::generate(), RefineSidesetGenerator::generate(), SideSetsBetweenSubdomainsGenerator::generate(), SideSetsFromPointsGenerator::generate(), MeshDiagnosticsGenerator::generate(), StackGenerator::generate(), ParsedGenerateNodeset::generate(), AdvancedExtruderGenerator::generate(), CircularBoundaryCorrectionGenerator::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 96 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 177 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 268 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 328 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 SideSetsFromBoundingBoxGenerator::generate(), XYZDelaunayGenerator::generate(), XYMeshLineCutter::generate(), XYDelaunayGenerator::generate(), and CutMeshByLevelSetGeneratorBase::generate().

getNextFreeBoundaryID() [2/2]

BoundaryID MooseMeshUtils::getNextFreeBoundaryID

(

MeshBase &

input_mesh

)

Definition at line 409 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 BoundaryLayerSubdomainGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), XYZDelaunayGenerator::generate(), XYDelaunayGenerator::generate(), and MeshRepairGenerator::separateSubdomainsByElementType().

getNextFreeSubdomainID() [2/2]

SubdomainID MooseMeshUtils::getNextFreeSubdomainID

(

MeshBase &

input_mesh

)

Definition at line 389 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 221 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 186 of file MooseMeshUtils.C.

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

{
  std::vector<SubdomainID> ids(subdomain_names.size());

  for (const auto i : index_range(subdomain_names))
    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 197 of file MooseMeshUtils.C.

{
  std::set<SubdomainID> ids;
  for (const auto & name : subdomain_names)
    ids.insert(MooseMeshUtils::getSubdomainID(name, mesh));
  return ids;
}

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 439 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(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), BreakBoundaryOnSubdomainGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), MeshDiagnosticsGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), and MultiAppNearestNodeTransfer::getTargetLocalNodes().

hasBoundaryName() [2/2]

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

Definition at line 453 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 BlockDeletionGenerator::generate(), CoarsenBlockGenerator::generate(), RefineBlockGenerator::generate(), AdvancedExtruderGenerator::generate(), MeshExtruderGenerator::generate(), and BreakMeshByElementGenerator::generate().

hasSubdomainID() [2/2]

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

Definition at line 418 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 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 432 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 365 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 347 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 356 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 362 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 460 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 533 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 25 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 StitchedMeshGenerator::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 FillBetweenSidesetsGenerator::generate(), and MultiAppPositions::initialize().

meshCentroidCalculator() [2/2]

Point MooseMeshUtils::meshCentroidCalculator

(

const MeshBase &

mesh

)

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