https://mooseframework.inl.gov
Functions
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< BoundaryIDgetBoundaryIDs (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< BoundaryIDgetBoundaryIDs (const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown)
 Gets the boundary IDs with their names. More...
 
std::set< BoundaryIDgetBoundaryIDSet (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_typegetSubdomainIDs (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_typegetSubdomainIDs (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 >
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_typegetExtraIDUniqueCombinationMap (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 >
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_typegetExtraIDUniqueCombinationMap (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< ReplicatedMeshbuildBoundaryMesh (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_meshThe input mesh
boundary_idThe 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.

585 {
586  auto poly_mesh = std::make_unique<ReplicatedMesh>(input_mesh.comm());
587 
588  auto side_list = input_mesh.get_boundary_info().build_side_list();
589 
590  std::unordered_map<dof_id_type, dof_id_type> old_new_node_map;
591  for (const auto & bside : side_list)
592  {
593  if (std::get<2>(bside) != boundary_id)
594  continue;
595 
596  const Elem * elem = input_mesh.elem_ptr(std::get<0>(bside));
597  const auto side = std::get<1>(bside);
598  auto side_elem = elem->build_side_ptr(side);
599  auto copy = side_elem->build(side_elem->type());
600 
601  for (const auto i : side_elem->node_index_range())
602  {
603  auto & n = side_elem->node_ref(i);
604 
605  if (old_new_node_map.count(n.id()))
606  copy->set_node(i, poly_mesh->node_ptr(old_new_node_map[n.id()]));
607  else
608  {
609  Node * node = poly_mesh->add_point(side_elem->point(i));
610  copy->set_node(i, node);
611  old_new_node_map[n.id()] = node->id();
612  }
613  }
614  poly_mesh->add_elem(copy.release());
615  }
616  poly_mesh->skip_partitioning(true);
617  poly_mesh->prepare_for_use();
618  if (poly_mesh->n_elem() == 0)
619  mooseError("The input mesh does not have a boundary with id ", boundary_id);
620 
621  return poly_mesh;
622 }
virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i)=0
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
const Parallel::Communicator & comm() const
const BoundaryInfo & get_boundary_info() const
void build_side_list(std::vector< dof_id_type > &element_id_list, std::vector< unsigned short int > &side_list, std::vector< boundary_id_type > &bc_id_list) const
virtual const Elem * elem_ptr(const dof_id_type i) const override final
dof_id_type id() const

◆ 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
meshthe mesh
old_idthe old boundary id
new_idthe new boundary id
delete_prevwhether 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.

56 {
57  // Get a reference to our BoundaryInfo object, we will use it several times below...
58  BoundaryInfo & boundary_info = mesh.get_boundary_info();
59 
60  // Container to catch ids passed back from BoundaryInfo
61  std::vector<boundary_id_type> old_ids;
62 
63  // Only level-0 elements store BCs. Loop over them.
64  for (auto & elem : as_range(mesh.level_elements_begin(0), mesh.level_elements_end(0)))
65  {
66  unsigned int n_sides = elem->n_sides();
67  for (const auto s : make_range(n_sides))
68  {
69  boundary_info.boundary_ids(elem, s, old_ids);
70  if (std::find(old_ids.begin(), old_ids.end(), old_id) != old_ids.end())
71  {
72  std::vector<boundary_id_type> new_ids(old_ids);
73  std::replace(new_ids.begin(), new_ids.end(), old_id, new_id);
74  if (delete_prev)
75  {
76  boundary_info.remove_side(elem, s);
77  boundary_info.add_side(elem, s, new_ids);
78  }
79  else
80  boundary_info.add_side(elem, s, new_ids);
81  }
82  }
83  }
84 
85  // Remove any remaining references to the old ID from the
86  // BoundaryInfo object. This prevents things like empty sidesets
87  // from showing up when printing information, etc.
88  if (delete_prev)
89  boundary_info.remove_id(old_id);
90 
91  // global information may now be out of sync
93 }
void remove_id(boundary_id_type id, bool global=false)
void set_isnt_prepared()
MeshBase & mesh
void boundary_ids(const Node *node, std::vector< boundary_id_type > &vec_to_fill) const
const BoundaryInfo & get_boundary_info() const
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
void remove_side(const Elem *elem, const unsigned short int side)
void add_side(const dof_id_type elem, const unsigned short int side, const boundary_id_type id)
IntRange< T > make_range(T beg, T end)

◆ 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
meshthe mesh
old_idthe old subdomain id
new_idthe 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.

240 {
241  for (const auto & elem : mesh.element_ptr_range())
242  if (elem->subdomain_id() == old_id)
243  elem->subdomain_id() = new_id;
244 
245  // global cached information may now be out of sync
247 }
void set_isnt_prepared()
MeshBase & mesh

◆ 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]pointPoint for which to compute distance from axis
[in]originAxis starting point
[in]directionAxis direction

Definition at line 174 of file MooseMeshUtils.h.

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

◆ 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.

200 {
201  coordTransformFactor(fi.faceCentroid(), fi.faceCoord(), coord_type, rz_radial_coord);
202 }
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
const Point & faceCentroid() const
Returns the coordinates of the face centroid.
Definition: FaceInfo.h:71
Real & faceCoord()
Sets/gets the coordinate transformation factor (for e.g.
Definition: FaceInfo.h:64

◆ 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
pointThe libMesh Point in space where we are evaluating the factor
factorThe 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_typeThe coordinate system type, e.g. cartesian (COORD_XYZ), cylindrical (COORD_RZ), or spherical (COORD_RSPHERICAL)
rz_radial_coordThe 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().

144 {
145  switch (coord_type)
146  {
147  case Moose::COORD_XYZ:
148  factor = 1.0;
149  break;
150  case Moose::COORD_RZ:
151  {
152  mooseAssert(rz_radial_coord != libMesh::invalid_uint,
153  "Must pass in a valid rz radial coordinate");
154  factor = 2 * M_PI * point(rz_radial_coord);
155  break;
156  }
158  factor = 4 * M_PI * point(0) * point(0);
159  break;
160  default:
161  mooseError("Unknown coordinate system");
162  }
163 }
const unsigned int invalid_uint
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302

◆ 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]pointThe libMesh Point in space where we are evaluating the factor
[in]axisThe pair of values defining the general axisymmetric axis. Respectively, the values are the axis starting point and direction.
[out]factorThe coordinate transformation factor

Definition at line 189 of file MooseMeshUtils.h.

Referenced by coordTransformFactor().

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

◆ 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_namename of the mesh generator class used for exception messages
num_sectionsnumber of sections in the mesh
num_integersnumber of extra element integers in the mesh
elem_integers_swapsvector of vectors of vectors of extra element ids to be swapped
elem_integers_swap_pairsvector of maps of the swapped pairs

Definition at line 552 of file MooseMeshUtils.C.

Referenced by AdvancedExtruderGenerator::AdvancedExtruderGenerator().

558 {
559  elem_integers_swap_pairs.reserve(num_sections * num_integers);
560  for (const auto i : make_range(num_integers))
561  {
562  const auto & elem_integer_swaps = elem_integers_swaps[i];
563  std::vector<std::unordered_map<dof_id_type, dof_id_type>> elem_integer_swap_pairs;
564  try
565  {
567  "elem_integers_swaps",
568  elem_integer_swaps,
569  elem_integer_swap_pairs,
570  i * num_sections);
571  }
572  catch (const MooseException & e)
573  {
574  throw MooseException(e.what());
575  }
576 
577  elem_integers_swap_pairs.insert(elem_integers_swap_pairs.end(),
578  elem_integer_swap_pairs.begin(),
579  elem_integer_swap_pairs.end());
580  }
581 }
virtual const char * what() const
Get out the error message.
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...
Provides a way for users to bail out of the current solve.
IntRange< T > make_range(T beg, T 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().

207 {
209  if (boundary_name.empty())
210  return id;
211 
212  if (!MooseUtils::isDigits(boundary_name))
213  id = mesh.get_boundary_info().get_id_by_name(boundary_name);
214  else
215  id = getIDFromName<BoundaryName, BoundaryID>(boundary_name);
216 
217  return id;
218 }
const BoundaryID INVALID_BOUNDARY_ID
Definition: MooseTypes.C:22
MeshBase & mesh
const BoundaryInfo & get_boundary_info() const
boundary_id_type get_id_by_name(std::string_view name) const
boundary_id_type BoundaryID
bool isDigits(const std::string &str)
Courtesy https://stackoverflow.com/a/8889045 and https://en.cppreference.com/w/cpp/string/byte/isdigi...
Definition: MooseUtils.h:1208

◆ 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().

109 {
110  const BoundaryInfo & boundary_info = mesh.get_boundary_info();
111  const std::map<BoundaryID, std::string> & sideset_map = boundary_info.get_sideset_name_map();
112  const std::map<BoundaryID, std::string> & nodeset_map = boundary_info.get_nodeset_name_map();
113 
114  BoundaryID max_boundary_local_id = 0;
115  /* It is required to generate a new ID for a given name. It is used often in mesh modifiers such
116  * as SideSetsBetweenSubdomains. Then we need to check the current boundary ids since they are
117  * changing during "mesh modify()", and figure out the right max boundary ID. Most of mesh
118  * modifiers are running in serial, and we won't involve a global communication.
119  */
120  if (generate_unknown)
121  {
124  max_boundary_local_id = bids.empty() ? 0 : *(bids.rbegin());
125  /* We should not hit this often */
126  if (!mesh.is_prepared() && !mesh.is_serial())
127  mesh.comm().max(max_boundary_local_id);
128  }
129 
130  BoundaryID max_boundary_id = mesh_boundary_ids.empty() ? 0 : *(mesh_boundary_ids.rbegin());
131 
132  max_boundary_id =
133  max_boundary_id > max_boundary_local_id ? max_boundary_id : max_boundary_local_id;
134 
135  std::vector<BoundaryID> ids(boundary_name.size());
136  for (const auto i : index_range(boundary_name))
137  {
138  if (boundary_name[i] == "ANY_BOUNDARY_ID")
139  {
140  ids.assign(mesh_boundary_ids.begin(), mesh_boundary_ids.end());
141  if (i)
142  mooseWarning("You passed \"ANY_BOUNDARY_ID\" in addition to other boundary_names. This "
143  "may be a logic error.");
144  break;
145  }
146 
147  if (boundary_name[i].empty() && !generate_unknown)
148  mooseError("Incoming boundary name is empty and we are not generating unknown boundary IDs. "
149  "This is invalid.");
150 
151  BoundaryID id;
152 
153  if (boundary_name[i].empty() || !MooseUtils::isDigits(boundary_name[i]))
154  {
160  if (generate_unknown &&
161  !MooseUtils::doesMapContainValue(sideset_map, std::string(boundary_name[i])) &&
162  !MooseUtils::doesMapContainValue(nodeset_map, std::string(boundary_name[i])))
163  id = ++max_boundary_id;
164  else
165  id = boundary_info.get_id_by_name(boundary_name[i]);
166  }
167  else
168  id = getIDFromName<BoundaryName, BoundaryID>(boundary_name[i]);
169 
170  ids[i] = id;
171  }
172 
173  return ids;
174 }
bool is_prepared() const
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
void mooseWarning(Args &&... args)
Emit a warning message with the given stringified, concatenated args.
Definition: MooseError.h:336
bool doesMapContainValue(const std::map< T1, T2 > &the_map, const T2 &value)
This routine is a simple helper function for searching a map by values instead of keys...
Definition: MooseUtils.h:356
const std::map< boundary_id_type, std::string > & get_sideset_name_map() const
MeshBase & mesh
const Parallel::Communicator & comm() const
const BoundaryInfo & get_boundary_info() const
boundary_id_type get_id_by_name(std::string_view name) const
virtual bool is_serial() const
const std::map< boundary_id_type, std::string > & get_nodeset_name_map() const
boundary_id_type BoundaryID
const std::set< boundary_id_type > & get_boundary_ids() const
void max(const T &r, T &o, Request &req) const
const std::set< boundary_id_type > & get_global_boundary_ids() const
bool isDigits(const std::string &str)
Courtesy https://stackoverflow.com/a/8889045 and https://en.cppreference.com/w/cpp/string/byte/isdigi...
Definition: MooseUtils.h:1208
auto index_range(const T &sizable)

◆ 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.

99 {
100  return getBoundaryIDs(
101  mesh, boundary_name, generate_unknown, mesh.get_boundary_info().get_boundary_ids());
102 }
MeshBase & mesh
const BoundaryInfo & get_boundary_info() const
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.
const std::set< boundary_id_type > & get_boundary_ids() const

◆ 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().

180 {
181  auto boundaries = getBoundaryIDs(mesh, boundary_name, generate_unknown);
182  return std::set<BoundaryID>(boundaries.begin(), boundaries.end());
183 }
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.

◆ 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
meshinput mesh
block_idsblock ids
extra_idsextra 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.

271 {
272  // check block restriction
273  const bool block_restricted = !block_ids.empty();
274  // get element id name of interest in recursive parsing algorithm
275  ExtraElementIDName id_name = extra_ids.back();
276  extra_ids.pop_back();
277  const auto id_index = mesh.get_elem_integer_index(id_name);
278 
279  // create base parsed id set
280  if (extra_ids.empty())
281  {
282  // get set of extra id values;
283  std::vector<dof_id_type> ids;
284  {
285  std::set<dof_id_type> ids_set;
286  for (const auto & elem : mesh.active_element_ptr_range())
287  {
288  if (block_restricted && block_ids.find(elem->subdomain_id()) == block_ids.end())
289  continue;
290  const auto id = elem->get_extra_integer(id_index);
291  ids_set.insert(id);
292  }
293  mesh.comm().set_union(ids_set);
294  ids.assign(ids_set.begin(), ids_set.end());
295  }
296 
297  // determine new extra id values;
298  std::unordered_map<dof_id_type, dof_id_type> parsed_ids;
299  for (auto & elem : mesh.active_element_ptr_range())
300  {
301  if (block_restricted && block_ids.find(elem->subdomain_id()) == block_ids.end())
302  continue;
303  parsed_ids[elem->id()] = std::distance(
304  ids.begin(), std::lower_bound(ids.begin(), ids.end(), elem->get_extra_integer(id_index)));
305  }
306  return parsed_ids;
307  }
308 
309  // if extra_ids is not empty, recursively call getExtraIDUniqueCombinationMap
310  const auto base_parsed_ids =
311  MooseMeshUtils::getExtraIDUniqueCombinationMap(mesh, block_ids, extra_ids);
312  // parsing extra ids based on ref_parsed_ids
313  std::vector<std::pair<dof_id_type, dof_id_type>> unique_ids;
314  {
315  std::set<std::pair<dof_id_type, dof_id_type>> unique_ids_set;
316  for (const auto & elem : mesh.active_element_ptr_range())
317  {
318  if (block_restricted && block_ids.find(elem->subdomain_id()) == block_ids.end())
319  continue;
320  const dof_id_type id1 = libmesh_map_find(base_parsed_ids, elem->id());
321  const dof_id_type id2 = elem->get_extra_integer(id_index);
322  const std::pair<dof_id_type, dof_id_type> ids = std::make_pair(id1, id2);
323  unique_ids_set.insert(ids);
324  }
325  mesh.comm().set_union(unique_ids_set);
326  unique_ids.assign(unique_ids_set.begin(), unique_ids_set.end());
327  }
328 
329  std::unordered_map<dof_id_type, dof_id_type> parsed_ids;
330 
331  for (const auto & elem : mesh.active_element_ptr_range())
332  {
333  if (block_restricted && block_ids.find(elem->subdomain_id()) == block_ids.end())
334  continue;
335  const dof_id_type id1 = libmesh_map_find(base_parsed_ids, elem->id());
336  const dof_id_type id2 = elem->get_extra_integer(id_index);
337  const dof_id_type new_id = std::distance(
338  unique_ids.begin(),
339  std::lower_bound(unique_ids.begin(), unique_ids.end(), std::make_pair(id1, id2)));
340  parsed_ids[elem->id()] = new_id;
341  }
342 
343  return parsed_ids;
344 }
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...
MeshBase & mesh
const Parallel::Communicator & comm() const
unsigned int get_elem_integer_index(std::string_view name) const
uint8_t dof_id_type
void set_union(T &data, const unsigned int root_id) const

◆ 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
nameName 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.

329 {
330  if (!MooseUtils::isDigits(name))
331  mooseError(
332  "'name' ", name, " should only contain digits that can be converted to a numerical type.");
333  long long id = std::stoll(name);
334  Q id_Q = Q(id);
336  mooseError(MooseUtils::prettyCppType<T>(&name),
337  " ",
338  name,
339  " is not within the numeric limits of the expected ID type ",
340  MooseUtils::prettyCppType<Q>(&id_Q),
341  ".");
342 
343  return id_Q;
344 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
auto max(const L &left, const R &right)
bool isDigits(const std::string &str)
Courtesy https://stackoverflow.com/a/8889045 and https://en.cppreference.com/w/cpp/string/byte/isdigi...
Definition: MooseUtils.h:1208
auto min(const L &left, const R &right)

◆ 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
inputmesh 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.

410 {
411  auto boundary_ids = input_mesh.get_boundary_info().get_boundary_ids();
412  if (boundary_ids.empty())
413  return 0;
414  return (*boundary_ids.rbegin() + 1);
415 }
const BoundaryInfo & get_boundary_info() const
const std::set< boundary_id_type > & get_boundary_ids() const

◆ 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
inputmesh 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.

390 {
391  // Call this to get most up to date block id information
392  input_mesh.cache_elem_data();
393 
394  std::set<SubdomainID> preexisting_subdomain_ids;
395  input_mesh.subdomain_ids(preexisting_subdomain_ids);
396  if (preexisting_subdomain_ids.empty())
397  return 0;
398  else
399  {
400  const auto highest_subdomain_id =
401  *std::max_element(preexisting_subdomain_ids.begin(), preexisting_subdomain_ids.end());
402  mooseAssert(highest_subdomain_id < std::numeric_limits<SubdomainID>::max(),
403  "A SubdomainID with max possible value was found");
404  return highest_subdomain_id + 1;
405  }
406 }
auto max(const L &left, const R &right)
void subdomain_ids(std::set< subdomain_id_type > &ids, const bool global=true) const

◆ 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().

222 {
223  if (subdomain_name == "ANY_BLOCK_ID")
224  mooseError("getSubdomainID() does not work with \"ANY_BLOCK_ID\"");
225 
227  if (subdomain_name.empty())
228  return id;
229 
230  if (!MooseUtils::isDigits(subdomain_name))
231  id = mesh.get_id_by_name(subdomain_name);
232  else
233  id = getIDFromName<SubdomainName, SubdomainID>(subdomain_name);
234 
235  return id;
236 }
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:302
MeshBase & mesh
subdomain_id_type get_id_by_name(std::string_view name) const
const SubdomainID INVALID_BLOCK_ID
Definition: MooseTypes.C:20
bool isDigits(const std::string &str)
Courtesy https://stackoverflow.com/a/8889045 and https://en.cppreference.com/w/cpp/string/byte/isdigi...
Definition: MooseUtils.h:1208

◆ 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
meshThe mesh
subdomain_nameThe 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().

187 {
188  std::vector<SubdomainID> ids(subdomain_names.size());
189 
190  for (const auto i : index_range(subdomain_names))
191  ids[i] = MooseMeshUtils::getSubdomainID(subdomain_names[i], mesh);
192 
193  return ids;
194 }
SubdomainID getSubdomainID(const SubdomainName &subdomain_name, const MeshBase &mesh)
Gets the subdomain ID associated with the given SubdomainName.
auto index_range(const T &sizable)

◆ 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.

198 {
199  std::set<SubdomainID> ids;
200  for (const auto & name : subdomain_names)
201  ids.insert(MooseMeshUtils::getSubdomainID(name, mesh));
202  return ids;
203 }
SubdomainID getSubdomainID(const SubdomainName &subdomain_name, const MeshBase &mesh)
Gets the subdomain ID associated with the given SubdomainName.

◆ hasBoundaryID() [1/2]

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

Whether a particular boundary ID exists in the mesh.

Parameters
inputmesh over which to determine boundary IDs
boundaryID

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

440 {
441  const BoundaryInfo & boundary_info = input_mesh.get_boundary_info();
442  std::set<boundary_id_type> boundary_ids = boundary_info.get_boundary_ids();
443 
444  // On a distributed mesh we may have boundary IDs that only exist on
445  // other processors
446  if (!input_mesh.is_replicated())
447  input_mesh.comm().set_union(boundary_ids);
448 
449  return boundary_ids.count(id) && (id != Moose::INVALID_BOUNDARY_ID);
450 }
const BoundaryID INVALID_BOUNDARY_ID
Definition: MooseTypes.C:22
const Parallel::Communicator & comm() const
const BoundaryInfo & get_boundary_info() const
const std::set< boundary_id_type > & get_boundary_ids() const
virtual bool is_replicated() const
void set_union(T &data, const unsigned int root_id) const

◆ hasBoundaryName() [1/2]

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

◆ hasBoundaryName() [2/2]

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

Definition at line 453 of file MooseMeshUtils.C.

454 {
455  const auto id = getBoundaryID(name, input_mesh);
456  return hasBoundaryID(input_mesh, id);
457 }
bool hasBoundaryID(const MeshBase &input_mesh, const BoundaryID id)
BoundaryID getBoundaryID(const BoundaryName &boundary_name, const MeshBase &mesh)

◆ hasSubdomainID() [1/2]

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

Whether a particular subdomain ID exists in the mesh.

Parameters
inputmesh over which to determine subdomain IDs
subdomainID

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

419 {
420  std::set<SubdomainID> mesh_blocks;
421  input_mesh.subdomain_ids(mesh_blocks);
422 
423  // On a distributed mesh we may have sideset IDs that only exist on
424  // other processors
425  if (!input_mesh.is_replicated())
426  input_mesh.comm().set_union(mesh_blocks);
427 
428  return mesh_blocks.count(id) && (id != Moose::INVALID_BLOCK_ID);
429 }
const Parallel::Communicator & comm() const
const SubdomainID INVALID_BLOCK_ID
Definition: MooseTypes.C:20
void subdomain_ids(std::set< subdomain_id_type > &ids, const bool global=true) const
virtual bool is_replicated() const
void set_union(T &data, const unsigned int root_id) const

◆ hasSubdomainName() [1/2]

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

◆ hasSubdomainName() [2/2]

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

Definition at line 432 of file MooseMeshUtils.C.

433 {
434  const auto id = getSubdomainID(name, input_mesh);
435  return hasSubdomainID(input_mesh, id);
436 }
SubdomainID getSubdomainID(const SubdomainName &subdomain_name, const MeshBase &mesh)
bool hasSubdomainID(const MeshBase &input_mesh, const SubdomainID &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_namename of the mesh generator class used for exception messages
id_namename of the parameter to be swapped used for exception messages
id_swapsvector of vectors of the ids to be swapped
id_swap_pairsvector of maps of the swapped pairs
row_index_shiftshift 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().

370 {
371  id_swap_pairs.resize(id_swaps.size());
372  for (const auto i : index_range(id_swaps))
373  {
374  const auto & swaps = id_swaps[i];
375  auto & swap_pairs = id_swap_pairs[i];
376 
377  if (swaps.size() % 2)
378  throw MooseException("Row ",
379  row_index_shift + i + 1,
380  " of ",
381  id_name,
382  " in ",
383  class_name,
384  " does not contain an even number of entries! Num entries: ",
385  swaps.size());
386 
387  swap_pairs.reserve(swaps.size() / 2);
388  for (unsigned int j = 0; j < swaps.size(); j += 2)
389  swap_pairs[swaps[j]] = swaps[j + 1];
390  }
391 }
Provides a way for users to bail out of the current solve.
auto index_range(const T &sizable)

◆ 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_ptsvector of points to be examined
plane_nvecnormal vector of the plane
fixed_pta 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_ptsvector of points to be examined
plane_nvecnormal 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_ptsvector 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.

348 {
349  for (const auto & pt : vec_pts)
350  if (!MooseUtils::absoluteFuzzyEqual((pt - fixed_pt) * plane_nvec, 0.0))
351  return false;
352  return true;
353 }
bool absoluteFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
Definition: MooseUtils.h:380

◆ isCoPlanar() [5/6]

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

Definition at line 356 of file MooseMeshUtils.C.

357 {
358  return isCoPlanar(vec_pts, plane_nvec, vec_pts.front());
359 }
bool isCoPlanar(const std::vector< Point > vec_pts)

◆ isCoPlanar() [6/6]

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

Definition at line 362 of file MooseMeshUtils.C.

Referenced by isCoPlanar().

363 {
364  // Assuming that overlapped Points are allowed, the Points that are overlapped with vec_pts[0] are
365  // removed before further calculation.
366  std::vector<Point> vec_pts_nonzero{vec_pts[0]};
367  for (const auto i : index_range(vec_pts))
368  if (!MooseUtils::absoluteFuzzyEqual((vec_pts[i] - vec_pts[0]).norm(), 0.0))
369  vec_pts_nonzero.push_back(vec_pts[i]);
370  // 3 or fewer points are always coplanar
371  if (vec_pts_nonzero.size() <= 3)
372  return true;
373  else
374  {
375  for (const auto i : make_range(vec_pts_nonzero.size() - 1))
376  {
377  const Point tmp_pt = (vec_pts_nonzero[i] - vec_pts_nonzero[0])
378  .cross(vec_pts_nonzero[i + 1] - vec_pts_nonzero[0]);
379  // if the three points are not collinear, use cross product as the normal vector of the plane
380  if (!MooseUtils::absoluteFuzzyEqual(tmp_pt.norm(), 0.0))
381  return isCoPlanar(vec_pts_nonzero, tmp_pt.unit());
382  }
383  }
384  // If all the points are collinear, they are also coplanar
385  return true;
386 }
auto norm() const -> decltype(std::norm(Real()))
bool absoluteFuzzyEqual(const T &var1, const T2 &var2, const T3 &tol=libMesh::TOLERANCE *libMesh::TOLERANCE)
Function to check whether two variables are equal within an absolute tolerance.
Definition: MooseUtils.h:380
TypeVector< Real > unit() const
auto norm(const T &a) -> decltype(std::abs(a))
bool isCoPlanar(const std::vector< Point > vec_pts)
IntRange< T > make_range(T beg, T end)
auto index_range(const T &sizable)

◆ 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_assmvector of pairs of node ids that represent the sides
elem_id_listvector of element ids that represent the elements that contain the sides
midpoint_node_listvector of node ids that represent the midpoints of the sides for quadratic sides
ordered_node_listvector of node ids that represent the ordered nodes
ordered_elem_id_listvector of element corresponding to the ordered nodes

Definition at line 460 of file MooseMeshUtils.C.

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

465 {
466  // a flag to indicate if the ordered_node_list has been reversed
467  bool is_flipped = false;
468  // Start from the first element, try to find a chain of nodes
469  mooseAssert(node_assm.size(), "Node list must not be empty");
470  ordered_node_list.push_back(node_assm.front().first);
471  if (midpoint_node_list.front() != DofObject::invalid_id)
472  ordered_node_list.push_back(midpoint_node_list.front());
473  ordered_node_list.push_back(node_assm.front().second);
474  ordered_elem_id_list.push_back(elem_id_list.front());
475  // Remove the element that has just been added to ordered_node_list
476  node_assm.erase(node_assm.begin());
477  midpoint_node_list.erase(midpoint_node_list.begin());
478  elem_id_list.erase(elem_id_list.begin());
479  const unsigned int node_assm_size_0 = node_assm.size();
480  for (unsigned int i = 0; i < node_assm_size_0; i++)
481  {
482  // Find nodes to expand the chain
483  dof_id_type end_node_id = ordered_node_list.back();
484  auto isMatch1 = [end_node_id](std::pair<dof_id_type, dof_id_type> old_id_pair)
485  { return old_id_pair.first == end_node_id; };
486  auto isMatch2 = [end_node_id](std::pair<dof_id_type, dof_id_type> old_id_pair)
487  { return old_id_pair.second == end_node_id; };
488  auto result = std::find_if(node_assm.begin(), node_assm.end(), isMatch1);
489  bool match_first;
490  if (result == node_assm.end())
491  {
492  match_first = false;
493  result = std::find_if(node_assm.begin(), node_assm.end(), isMatch2);
494  }
495  else
496  {
497  match_first = true;
498  }
499  // If found, add the node to boundary_ordered_node_list
500  if (result != node_assm.end())
501  {
502  const auto elem_index = std::distance(node_assm.begin(), result);
503  if (midpoint_node_list[elem_index] != DofObject::invalid_id)
504  ordered_node_list.push_back(midpoint_node_list[elem_index]);
505  ordered_node_list.push_back(match_first ? (*result).second : (*result).first);
506  node_assm.erase(result);
507  midpoint_node_list.erase(midpoint_node_list.begin() + elem_index);
508  ordered_elem_id_list.push_back(elem_id_list[elem_index]);
509  elem_id_list.erase(elem_id_list.begin() + elem_index);
510  }
511  // If there are still elements in node_assm and result ==
512  // node_assm.end(), this means the curve is not a loop, the
513  // ordered_node_list is flipped and try the other direction that has not
514  // been examined yet.
515  else
516  {
517  if (is_flipped)
518  // Flipped twice; this means the node list has at least two segments.
519  throw MooseException("The node list provided has more than one segments.");
520 
521  // mark the first flip event.
522  is_flipped = true;
523  std::reverse(ordered_node_list.begin(), ordered_node_list.end());
524  std::reverse(midpoint_node_list.begin(), midpoint_node_list.end());
525  std::reverse(ordered_elem_id_list.begin(), ordered_elem_id_list.end());
526  // As this iteration is wasted, set the iterator backward
527  i--;
528  }
529  }
530 }
Provides a way for users to bail out of the current solve.
uint8_t dof_id_type

◆ 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_assmvector of pairs of node ids that represent the sides
elem_id_listvector of element ids that represent the elements that contain the sides
ordered_node_listvector of node ids that represent the ordered nodes
ordered_elem_id_listvector of element corresponding to the ordered nodes

Definition at line 533 of file MooseMeshUtils.C.

537 {
538  std::vector<dof_id_type> dummy_midpoint_node_list(node_assm.size(), DofObject::invalid_id);
540  node_assm, elem_id_list, dummy_midpoint_node_list, ordered_node_list, ordered_elem_id_list);
541 }
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 bas...

◆ mergeBoundaryIDsWithSameName() [1/2]

void MooseMeshUtils::mergeBoundaryIDsWithSameName ( MeshBase mesh)

Definition at line 25 of file MooseMeshUtils.C.

26 {
27  // We check if we have the same boundary name with different IDs. If we do, we assign the
28  // first ID to every occurrence.
29  const auto & side_bd_name_map = mesh.get_boundary_info().get_sideset_name_map();
30  const auto & node_bd_name_map = mesh.get_boundary_info().get_nodeset_name_map();
31  std::map<boundary_id_type, boundary_id_type> same_name_ids;
32 
33  auto populate_map = [](const std::map<boundary_id_type, std::string> & map,
34  std::map<boundary_id_type, boundary_id_type> & same_ids)
35  {
36  for (const auto & pair_outer : map)
37  for (const auto & pair_inner : map)
38  // The last condition is needed to make sure we only store one combination
39  if (pair_outer.second == pair_inner.second && pair_outer.first != pair_inner.first &&
40  same_ids.find(pair_inner.first) == same_ids.end())
41  same_ids[pair_outer.first] = pair_inner.first;
42  };
43 
44  populate_map(side_bd_name_map, same_name_ids);
45  populate_map(node_bd_name_map, same_name_ids);
46 
47  for (const auto & [id1, id2] : same_name_ids)
49 }
const std::map< boundary_id_type, std::string > & get_sideset_name_map() const
MeshBase & mesh
const BoundaryInfo & get_boundary_info() const
void renumber_id(boundary_id_type old_id, boundary_id_type new_id)
const std::map< boundary_id_type, std::string > & get_nodeset_name_map() const

◆ mergeBoundaryIDsWithSameName() [2/2]

void MooseMeshUtils::mergeBoundaryIDsWithSameName ( MeshBase &  mesh)

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

Parameters
meshThe 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
meshinput 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.

251 {
252  Point centroid_pt = Point(0.0, 0.0, 0.0);
253  Real vol_tmp = 0.0;
254  for (const auto & elem :
255  as_range(mesh.active_local_elements_begin(), mesh.active_local_elements_end()))
256  {
257  Real elem_vol = elem->volume();
258  centroid_pt += (elem->true_centroid()) * elem_vol;
259  vol_tmp += elem_vol;
260  }
261  mesh.comm().sum(centroid_pt);
262  mesh.comm().sum(vol_tmp);
263  centroid_pt /= vol_tmp;
264  return centroid_pt;
265 }
MeshBase & mesh
const Parallel::Communicator & comm() const
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

◆ swapNodesInElem() [1/2]

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

Swap two nodes within an element.

Parameters
elemelement whose nodes need to be swapped
nd1index of the first node to be swapped
nd2index 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.

545 {
546  Node * n_temp = elem.node_ptr(nd1);
547  elem.set_node(nd1, elem.node_ptr(nd2));
548  elem.set_node(nd2, n_temp);
549 }
virtual Node *& set_node(const unsigned int i)
const Node * node_ptr(const unsigned int i) const