31 #include "libmesh/bounding_box.h" 32 #include "libmesh/boundary_info.h" 33 #include "libmesh/mesh_tools.h" 34 #include "libmesh/parallel.h" 35 #include "libmesh/mesh_communication.h" 36 #include "libmesh/periodic_boundary_base.h" 37 #include "libmesh/fe_base.h" 38 #include "libmesh/fe_interface.h" 39 #include "libmesh/mesh_inserter_iterator.h" 40 #include "libmesh/mesh_communication.h" 41 #include "libmesh/mesh_inserter_iterator.h" 42 #include "libmesh/mesh_tools.h" 43 #include "libmesh/parallel.h" 44 #include "libmesh/parallel_elem.h" 45 #include "libmesh/parallel_node.h" 46 #include "libmesh/parallel_ghost_sync.h" 47 #include "libmesh/utility.h" 48 #include "libmesh/remote_elem.h" 49 #include "libmesh/linear_partitioner.h" 50 #include "libmesh/centroid_partitioner.h" 51 #include "libmesh/parmetis_partitioner.h" 52 #include "libmesh/hilbert_sfc_partitioner.h" 53 #include "libmesh/morton_sfc_partitioner.h" 54 #include "libmesh/edge_edge2.h" 55 #include "libmesh/mesh_refinement.h" 56 #include "libmesh/quadrature.h" 57 #include "libmesh/boundary_info.h" 58 #include "libmesh/periodic_boundaries.h" 59 #include "libmesh/quadrature_gauss.h" 60 #include "libmesh/point_locator_base.h" 61 #include "libmesh/default_coupling.h" 62 #include "libmesh/ghost_point_neighbors.h" 63 #include "libmesh/fe_type.h" 64 #include "libmesh/enum_to_string.h" 72 #if NANOFLANN_VERSION < 0x150 77 template <
typename T,
typename U>
87 MooseEnum parallel_type(
"DEFAULT REPLICATED DISTRIBUTED",
"DEFAULT");
90 "DEFAULT: Use libMesh::ReplicatedMesh unless --distributed-mesh is " 91 "specified on the command line " 92 "REPLICATED: Always use libMesh::ReplicatedMesh " 93 "DISTRIBUTED: Always use libMesh::DistributedMesh");
98 "If allow_renumbering=false, node and element numbers are kept fixed until deletion");
103 "If nemesis=true and file=foo.e, actually reads " 104 "foo.e.N.0, foo.e.N.1, ... foo.e.N.N-1, " 105 "where N = # CPUs, with NemesisIO.");
110 "Specifies a mesh partitioner to use when splitting the mesh for a parallel computation.");
114 "Specifies the sort direction if using the centroid partitioner. " 115 "Available options: x, y, z, radial");
117 MooseEnum patch_update_strategy(
"never always auto iteration",
"never");
119 "patch_update_strategy",
120 patch_update_strategy,
121 "How often to update the geometric search 'patch'. The default is to " 122 "never update it (which is the most efficient but could be a problem " 123 "with lots of relative motion). 'always' will update the patch for all " 124 "secondary nodes at the beginning of every timestep which might be time " 125 "consuming. 'auto' will attempt to determine at the start of which " 126 "timesteps the patch for all secondary nodes needs to be updated automatically." 127 "'iteration' updates the patch at every nonlinear iteration for a " 128 "subset of secondary nodes for which penetration is not detected. If there " 129 "can be substantial relative motion between the primary and secondary surfaces " 130 "during the nonlinear iterations within a timestep, it is advisable to use " 131 "'iteration' option to ensure accurate contact detection.");
135 "construct_node_list_from_side_list",
137 "Whether or not to generate nodesets from the sidesets (usually a good idea).");
139 "patch_size", 40,
"The number of nodes to consider in the NearestNode neighborhood.");
140 params.
addParam<
unsigned int>(
"ghosting_patch_size",
141 "The number of nearest neighbors considered " 142 "for ghosting purposes when 'iteration' " 143 "patch update strategy is used. Default is " 145 params.
addParam<
unsigned int>(
"max_leaf_size",
147 "The maximum number of points in each leaf of the KDTree used in " 148 "the nearest neighbor search. As the leaf size becomes larger," 149 "KDTree construction becomes faster but the nearest neighbor search" 152 params.
addParam<
bool>(
"build_all_side_lowerd_mesh",
154 "True to build the lower-dimensional mesh for all sides.");
156 params.
addParam<
bool>(
"skip_refine_when_use_split",
158 "True to skip uniform refinements when using a pre-split mesh.");
160 params.
addParam<std::vector<SubdomainID>>(
162 "The listed subdomain ids will be assumed valid for the mesh. This permits setting up " 163 "subdomain restrictions for subdomains initially containing no elements, which can occur, " 164 "for example, in additive manufacturing simulations which dynamically add and remove " 165 "elements. Names for this subdomains may be provided using add_subdomain_names. In this case " 166 "this list and add_subdomain_names must contain the same number of items.");
167 params.
addParam<std::vector<SubdomainName>>(
168 "add_subdomain_names",
169 "The listed subdomain names will be assumed valid for the mesh. This permits setting up " 170 "subdomain restrictions for subdomains initially containing no elements, which can occur, " 171 "for example, in additive manufacturing simulations which dynamically add and remove " 172 "elements. IDs for this subdomains may be provided using add_subdomain_ids. Otherwise IDs " 173 "are automatically assigned. In case add_subdomain_ids is set too, both lists must contain " 174 "the same number of items.");
176 params.
addParam<std::vector<BoundaryID>>(
178 "The listed sideset ids will be assumed valid for the mesh. This permits setting up boundary " 179 "restrictions for sidesets initially containing no sides. Names for this sidesets may be " 180 "provided using add_sideset_names. In this case this list and add_sideset_names must contain " 181 "the same number of items.");
182 params.
addParam<std::vector<BoundaryName>>(
184 "The listed sideset names will be assumed valid for the mesh. This permits setting up " 185 "boundary restrictions for sidesets initially containing no sides. Ids for this sidesets may " 186 "be provided using add_sideset_ids. In this case this list and add_sideset_ids must contain " 187 "the same number of items.");
189 params.
addParam<std::vector<BoundaryID>>(
191 "The listed nodeset ids will be assumed valid for the mesh. This permits setting up boundary " 192 "restrictions for node initially containing no sides. Names for this nodesets may be " 193 "provided using add_nodeset_names. In this case this list and add_nodeset_names must contain " 194 "the same number of items.");
195 params.
addParam<std::vector<BoundaryName>>(
197 "The listed nodeset names will be assumed valid for the mesh. This permits setting up " 198 "boundary restrictions for nodesets initially containing no sides. Ids for this nodesets may " 199 "be provided using add_nodesets_ids. In this case this list and add_nodesets_ids must " 200 "contain the same number of items.");
206 params.addPrivateParam<
bool>(
"_mesh_generator_mesh",
false);
209 params.addPrivateParam<
bool>(
"_is_split",
false);
211 params.registerBase(
"MooseMesh");
214 params.addParamNamesToGroup(
"patch_update_strategy patch_size max_leaf_size",
"Geometric search");
215 params.addParamNamesToGroup(
"nemesis",
"Advanced");
216 params.addParamNamesToGroup(
"add_subdomain_ids add_subdomain_names add_sideset_ids " 217 "add_sideset_names add_nodeset_ids add_nodeset_names",
218 "Pre-declaration of future mesh sub-entities");
219 params.addParamNamesToGroup(
"construct_node_list_from_side_list build_all_side_lowerd_mesh",
220 "Automatic definition of mesh element sides entities");
221 params.addParamNamesToGroup(
"partitioner centroid_partitioner_direction",
"Partitioning");
231 _use_distributed_mesh(false),
232 _distribution_overridden(false),
233 _parallel_type_overridden(false),
235 _partitioner_name(getParam<
MooseEnum>(
"partitioner")),
236 _partitioner_overridden(false),
237 _custom_partitioner_requested(false),
238 _uniform_refine_level(0),
239 _skip_refine_when_use_split(getParam<bool>(
"skip_refine_when_use_split")),
240 _skip_deletion_repartition_after_refine(false),
241 _is_nemesis(getParam<bool>(
"nemesis")),
242 _node_to_elem_map_built(false),
243 _node_to_active_semilocal_elem_map_built(false),
244 _patch_size(getParam<unsigned
int>(
"patch_size")),
245 _ghosting_patch_size(isParamValid(
"ghosting_patch_size")
246 ? getParam<unsigned
int>(
"ghosting_patch_size")
248 _max_leaf_size(getParam<unsigned
int>(
"max_leaf_size")),
249 _patch_update_strategy(
251 _regular_orthogonal_mesh(false),
252 _is_split(getParam<bool>(
"_is_split")),
254 _allow_recovery(true),
255 _construct_node_list_from_side_list(getParam<bool>(
"construct_node_list_from_side_list")),
257 _allow_remote_element_removal(true),
258 _need_ghost_ghosted_boundaries(true),
259 _is_displaced(false),
262 _rz_coord_axis(getParam<
MooseEnum>(
"rz_coord_axis")),
263 _coord_system_set(false),
264 _doing_p_refinement(false)
267 mooseError(
"Ghosting patch size parameter has to be set in the mesh block " 268 "only when 'iteration' patch update strategy is used.");
274 "You set both 'Mesh/block' and 'Mesh/coord_block'. The value of " 275 "'Mesh/coord_block' will be used.");
282 if (getParam<bool>(
"build_all_side_lowerd_mesh"))
293 _built_from_other_mesh(true),
294 _parallel_type(other_mesh._parallel_type),
295 _use_distributed_mesh(other_mesh._use_distributed_mesh),
296 _distribution_overridden(other_mesh._distribution_overridden),
297 _parallel_type_overridden(other_mesh._parallel_type_overridden),
298 _mesh(other_mesh.getMesh().clone()),
299 _partitioner_name(other_mesh._partitioner_name),
300 _partitioner_overridden(other_mesh._partitioner_overridden),
301 _custom_partitioner_requested(other_mesh._custom_partitioner_requested),
302 _uniform_refine_level(other_mesh.uniformRefineLevel()),
303 _skip_refine_when_use_split(other_mesh._skip_refine_when_use_split),
304 _skip_deletion_repartition_after_refine(other_mesh._skip_deletion_repartition_after_refine),
306 _node_to_elem_map_built(false),
307 _node_to_active_semilocal_elem_map_built(false),
308 _patch_size(other_mesh._patch_size),
309 _ghosting_patch_size(other_mesh._ghosting_patch_size),
310 _max_leaf_size(other_mesh._max_leaf_size),
311 _patch_update_strategy(other_mesh._patch_update_strategy),
312 _regular_orthogonal_mesh(false),
313 _is_split(other_mesh._is_split),
314 _lower_d_interior_blocks(other_mesh._lower_d_interior_blocks),
315 _lower_d_boundary_blocks(other_mesh._lower_d_boundary_blocks),
316 _has_lower_d(other_mesh._has_lower_d),
317 _allow_recovery(other_mesh._allow_recovery),
318 _construct_node_list_from_side_list(other_mesh._construct_node_list_from_side_list),
319 _need_delete(other_mesh._need_delete),
320 _allow_remote_element_removal(other_mesh._allow_remote_element_removal),
321 _need_ghost_ghosted_boundaries(other_mesh._need_ghost_ghosted_boundaries),
322 _coord_sys(other_mesh._coord_sys),
323 _rz_coord_axis(other_mesh._rz_coord_axis),
324 _subdomain_id_to_rz_coord_axis(other_mesh._subdomain_id_to_rz_coord_axis),
325 _coord_system_set(other_mesh._coord_system_set),
326 _provided_coord_blocks(other_mesh._provided_coord_blocks),
327 _doing_p_refinement(other_mesh._doing_p_refinement)
333 const std::set<SubdomainID> & subdomains = other_mesh.
meshSubdomains();
334 for (
const auto & sbd_id : subdomains)
342 std::vector<BoundaryID> side_boundaries;
346 for (
const auto & side_bnd_id : side_boundaries)
347 boundary_info.
sideset_name(side_bnd_id) = other_boundary_info.get_sideset_name(side_bnd_id);
350 std::vector<BoundaryID> node_boundaries;
351 other_boundary_info.build_node_boundary_ids(node_boundaries);
353 for (
const auto & node_bnd_id : node_boundaries)
354 boundary_info.
nodeset_name(node_bnd_id) = other_boundary_info.get_nodeset_name(node_bnd_id);
357 for (std::size_t i = 0; i <
_bounds.size(); ++i)
360 for (std::size_t j = 0; j <
_bounds[i].size(); ++j)
408 TIME_SECTION(
"prepare", 2,
"Preparing Mesh",
true);
410 bool called_prepare_for_use =
false;
412 mooseAssert(
_mesh,
"The MeshBase has not been constructed");
421 "The mesh we wish to clone from must already be prepared");
425 else if (!
_mesh->is_prepared())
427 _mesh->prepare_for_use();
429 called_prepare_for_use =
true;
433 return called_prepare_for_use;
437 for (
const auto &
elem :
getMesh().element_ptr_range())
444 const auto & add_subdomain_id = getParam<std::vector<SubdomainID>>(
"add_subdomain_ids");
449 const auto add_subdomain =
450 getParam<SubdomainID, SubdomainName>(
"add_subdomain_ids",
"add_subdomain_names");
451 for (
const auto & [sub_id, sub_name] : add_subdomain)
462 const auto & add_subdomain_names = getParam<std::vector<SubdomainName>>(
"add_subdomain_names");
470 for (
const SubdomainName & sub_name : add_subdomain_names)
475 const auto sub_id = ++offset;
490 const std::set<BoundaryID> & local_node_bids =
494 const std::set<BoundaryID> & local_side_bids =
500 auto add_sets = [
this](
const bool sidesets,
auto & set_ids)
502 const std::string
type = sidesets ?
"sideset" :
"nodeset";
503 const std::string id_param =
"add_" +
type +
"_ids";
504 const std::string name_param =
"add_" +
type +
"_names";
508 const auto & add_ids = getParam<std::vector<BoundaryID>>(id_param);
510 set_ids.insert(add_ids.begin(), add_ids.end());
513 const auto & add_names = getParam<std::vector<BoundaryName>>(name_param);
514 mooseAssert(add_names.size() == add_ids.size(),
515 "Id and name sets must be the same size when adding.");
523 const auto & add_names = getParam<std::vector<BoundaryName>>(name_param);
529 if (!mesh_ids.empty())
530 offset = *mesh_ids.rbegin();
535 for (
const auto &
name : add_names)
540 const auto id = ++offset;
568 "Trying to set coordinate system type information based on the user input file, but " 569 "the coordinate system type information has already been set programmatically! " 570 "Either remove your coordinate system type information from the input file, or contact " 571 "your application developer");
578 const auto rz_coord_blocks = getParam<std::vector<SubdomainName>>(
"rz_coord_blocks");
579 const auto rz_coord_origins = getParam<std::vector<Point>>(
"rz_coord_origins");
580 const auto rz_coord_directions = getParam<std::vector<RealVectorValue>>(
"rz_coord_directions");
581 if (rz_coord_origins.size() == rz_coord_blocks.size() &&
582 rz_coord_directions.size() == rz_coord_blocks.size())
584 std::vector<std::pair<Point, RealVectorValue>> rz_coord_axes;
585 for (
unsigned int i = 0; i < rz_coord_origins.size(); ++i)
586 rz_coord_axes.push_back(std::make_pair(rz_coord_origins[i], rz_coord_directions[i]));
591 mooseError(
"The parameter 'rz_coord_axis' may not be provided if 'rz_coord_blocks', " 592 "'rz_coord_origins', and 'rz_coord_directions' are provided.");
595 mooseError(
"The parameters 'rz_coord_blocks', 'rz_coord_origins', and " 596 "'rz_coord_directions' must all have the same size.");
600 mooseError(
"If any of the parameters 'rz_coord_blocks', 'rz_coord_origins', and " 601 "'rz_coord_directions' are provided, then all must be provided.");
612 return called_prepare_for_use;
618 TIME_SECTION(
"update", 3,
"Updating Mesh",
true);
638 for (
const auto &
elem :
getMesh().active_local_element_ptr_range())
661 "Hybrid finite element method must use replicated mesh.\nCurrently lower-dimensional mesh " 662 "does not support mesh re-partitioning and a debug assertion being hit related with " 663 "neighbors of lower-dimensional element, with distributed mesh.");
670 unsigned int max_n_sides = 0;
673 std::set<Elem *> deleteable_elems;
674 for (
auto &
elem :
mesh.element_ptr_range())
677 deleteable_elems.insert(
elem);
681 for (
auto &
elem : deleteable_elems)
692 deleteable_elems.clear();
695 std::set<int> interior_side_types;
696 std::set<int> boundary_side_types;
697 for (
const auto &
elem :
mesh.active_element_ptr_range())
703 interior_side_types.insert(side_elem->type());
705 boundary_side_types.insert(side_elem->type());
711 std::map<ElemType, SubdomainID> interior_block_ids;
712 std::map<ElemType, SubdomainID> boundary_block_ids;
715 for (
const auto & tpid : interior_side_types)
719 interior_block_ids[
type] = id;
722 mooseError(
"Trying to add a mesh block with id ",
id,
" that has existed in the mesh");
726 for (
const auto & tpid : boundary_side_types)
730 boundary_block_ids[
type] = id;
733 mooseError(
"Trying to add a mesh block with id ",
id,
" that has existed in the mesh");
741 std::vector<Elem *> side_elems;
743 for (
const auto &
elem :
mesh.active_element_ptr_range())
753 bool build_side =
false;
758 mooseAssert(!neig->
is_remote(),
"We error if the mesh is not serial");
774 side_elem->subdomain_id() = interior_block_ids.at(side_elem->type());
776 side_elem->subdomain_id() = boundary_block_ids.at(side_elem->type());
779 side_elem->set_id(max_elem_id +
elem->
id() * max_n_sides + side);
780 side_elem->set_unique_id(max_unique_id +
elem->
id() * max_n_sides + side);
785 side_elem->set_interior_parent(
elem);
787 side_elems.push_back(side_elem.release());
790 auto pair = std::make_pair(
elem, side);
791 auto link = std::make_pair(pair, side_elems.back());
792 auto ilink = std::make_pair(side_elems.back(), side);
803 for (
auto &
elem : side_elems)
819 mooseDeprecated(
"MooseMesh::node() is deprecated, please use MooseMesh::nodeRef() instead");
826 mooseDeprecated(
"MooseMesh::node() is deprecated, please use MooseMesh::nodeRef() instead");
834 mooseAssert(node_ptr,
"Missing node");
859 if (i >
getMesh().max_node_id())
864 auto & node_ptr = it->second;
865 mooseAssert(node_ptr,
"Uninitialized quadrature node");
881 TIME_SECTION(
"meshChanged", 3,
"Updating Because Mesh Changed");
912 TIME_SECTION(
"cacheChangedLists", 5,
"Caching Changed Lists");
916 Threads::parallel_reduce(elem_range, cclt);
939 const std::vector<const Elem *> &
944 return elem_to_child_pair->second;
950 TIME_SECTION(
"updateActiveSemiLocalNodeRange", 5,
"Updating ActiveSemiLocalNode Range");
956 for (
const auto &
elem : *active_local_elems)
972 for (
const auto & ghost_elem_id : ghosted_elems)
1024 TIME_SECTION(
"buildNodeList", 5,
"Building Node List");
1030 int n = bc_tuples.size();
1033 for (
const auto & t : bc_tuples)
1035 auto node_id = std::get<0>(t);
1036 auto bc_id = std::get<1>(t);
1069 for (
const auto &
elem :
getMesh().active_local_element_ptr_range())
1070 for (
unsigned int i = 0; i < n; ++i)
1078 for (
unsigned int j = 0; j < n; ++j)
1086 for (
unsigned int i = 0; i < n; ++i)
1096 std::unordered_map<dof_id_type, std::set<dof_id_type>>
1101 if (!mesh_base.has_elem_integer(from_id_name))
1102 mooseError(
"Mesh does not have the element integer name '", from_id_name,
"'");
1103 if (!mesh_base.has_elem_integer(to_id_name))
1104 mooseError(
"Mesh does not have the element integer name '", to_id_name,
"'");
1106 const auto id1 = mesh_base.get_elem_integer_index(from_id_name);
1107 const auto id2 = mesh_base.get_elem_integer_index(to_id_name);
1109 std::unordered_map<dof_id_type, std::set<dof_id_type>> id_map;
1111 id_map[id] = std::set<dof_id_type>();
1113 for (
const auto &
elem : mesh_base.active_local_element_ptr_range())
1116 for (
auto & [
id, ids] : id_map)
1125 std::set<dof_id_type>
1128 std::set<dof_id_type> unique_ids;
1130 for (
auto &
id : pair.second)
1131 unique_ids.insert(
id);
1135 std::set<dof_id_type>
1138 std::set<dof_id_type> unique_ids;
1139 for (
auto & blk : blks)
1143 mooseError(
"Block ", blk,
" is not available on the mesh");
1145 for (
auto & mid : it->second)
1146 unique_ids.insert(mid);
1154 TIME_SECTION(
"buildBndElemList", 5,
"Building Boundary Elements List");
1160 int n = bc_tuples.size();
1163 for (
const auto & t : bc_tuples)
1165 auto elem_id = std::get<0>(t);
1166 auto side_id = std::get<1>(t);
1167 auto bc_id = std::get<2>(t);
1174 const std::map<dof_id_type, std::vector<dof_id_type>> &
1179 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1188 Threads::in_threads =
false;
1189 TIME_SECTION(
"nodeToElemMap", 5,
"Building Node To Elem Map");
1192 for (
const auto &
elem :
getMesh().active_element_ptr_range())
1193 for (
unsigned int n = 0; n <
elem->
n_nodes(); n++)
1202 const std::map<dof_id_type, std::vector<dof_id_type>> &
1207 Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
1214 Threads::in_threads =
false;
1215 TIME_SECTION(
"nodeToActiveSemilocalElemMap", 5,
"Building SemiLocalElemMap");
1220 for (
const auto &
elem :
1223 for (
unsigned int n = 0; n <
elem->
n_nodes(); n++)
1239 TIME_SECTION(
"getActiveLocalElementRange", 5);
1253 TIME_SECTION(
"getActiveNodeRange", 5);
1266 "_active_semilocal_node_range has not been created yet!");
1276 TIME_SECTION(
"getLocalNodeRange", 5);
1290 TIME_SECTION(
"getBoundaryNodeRange", 5);
1304 TIME_SECTION(
"getBoundaryElementRange", 5);
1313 const std::unordered_map<boundary_id_type, std::unordered_set<dof_id_type>> &
1317 "use MooseMesh::getBoundariesToActiveSemiLocalElemIds");
1321 const std::unordered_map<boundary_id_type, std::unordered_set<dof_id_type>> &
1327 std::unordered_set<dof_id_type>
1334 return std::unordered_set<dof_id_type>{};
1338 std::unordered_set<dof_id_type>
1342 std::unordered_set<dof_id_type> neighbor_elems;
1345 const auto & [elem_ptr, elem_side, elem_bid] = *bnd_elem;
1346 if (elem_bid == bid)
1348 const auto * neighbor = elem_ptr->neighbor_ptr(elem_side);
1353 if (neighbor->active())
1354 neighbor_elems.insert(neighbor->id());
1357 std::vector<const Elem *> family;
1358 neighbor->active_family_tree_by_neighbor(family, elem_ptr);
1359 for (
const auto & child_neighbor : family)
1360 neighbor_elems.insert(child_neighbor->id());
1366 return neighbor_elems;
1371 const std::set<SubdomainID> & blk_group)
const 1373 mooseAssert(
_bnd_elem_range,
"Boundary element range is not initialized");
1378 const auto & [elem_ptr, elem_side, elem_bid] = *bnd_elem;
1379 if (elem_bid == bid)
1382 if (blk_group.find(elem_ptr->subdomain_id()) != blk_group.end())
1384 const auto *
const neighbor = elem_ptr->neighbor_ptr(elem_side);
1388 mooseError(
"Insufficient level of geometrical ghosting to determine " 1389 "if a boundary is internal to the mesh");
1395 if (blk_group.find(neighbor->subdomain_id()) != blk_group.end())
1406 TIME_SECTION(
"cacheInfo", 3);
1420 for (
const auto &
elem :
mesh.element_ptr_range())
1433 auto pair = std::make_pair(ip_elem, ip_side);
1435 std::pair<std::pair<const Elem *, unsigned short int>,
const Elem *>(pair,
elem));
1437 std::pair<const Elem *, unsigned short int>(
elem, ip_side));
1442 if (
mesh.
subdomain_name(
id).find(
"INTERNAL_SIDE_LOWERD_SUBDOMAIN_") != std::string::npos)
1447 if (
mesh.
subdomain_name(
id).find(
"BOUNDARY_SIDE_LOWERD_SUBDOMAIN_") != std::string::npos)
1453 for (
unsigned int nd = 0; nd <
elem->
n_nodes(); ++nd)
1462 for (
const auto &
elem :
mesh.active_local_element_ptr_range())
1466 for (
unsigned int side = 0; side <
elem->
n_sides(); side++)
1469 sub_data.boundary_ids.insert(boundary_ids.begin(), boundary_ids.end());
1475 boundary_ids.end());
1477 if (neighbor_subdomain_id != subdomain_id)
1478 sub_data.neighbor_subs.insert(neighbor_subdomain_id);
1489 if (sub_data.is_lower_d)
1495 const std::set<SubdomainID> &
1583 for (
const auto &
node :
getMesh().node_ptr_range())
1588 for (
unsigned int i = 0; i <
_node_map.size(); ++i)
1596 if (
node ==
nullptr)
1602 mooseAssert(
node !=
nullptr,
"Node is NULL");
1608 const unsigned short int side,
1609 const unsigned int qp,
1611 const Point & point)
1628 if (new_id <=
getMesh().max_node_id())
1629 mooseError(
"Quadrature node id collides with existing node id!");
1631 qnode =
new Node(point, new_id);
1660 const unsigned short int side,
1661 const unsigned int qp)
1665 "Elem has no quadrature nodes!");
1668 "Side has no quadrature nodes!");
1671 "qp not found on side!");
1691 if (boundary_name ==
"ANY_BOUNDARY_ID")
1692 mooseError(
"Please use getBoundaryIDs() when passing \"ANY_BOUNDARY_ID\"");
1719 std::vector<BoundaryID>
1721 bool generate_unknown)
const 1733 std::vector<SubdomainID>
1739 std::set<SubdomainID>
1763 std::vector<SubdomainName>
1766 std::vector<SubdomainName> names(subdomain_ids.size());
1768 for (
unsigned int i = 0; i < subdomain_ids.size(); i++)
1800 inline const Point &
1804 return *(item.first);
1809 unsigned int var_number,
1812 TIME_SECTION(
"buildPeriodicNodeMap", 5);
1815 periodic_node_map.clear();
1818 std::vector<PeriodicNodeInfo> periodic_nodes;
1819 for (
const auto & t :
getMesh().get_boundary_info().build_node_list())
1822 auto node =
_mesh->node_ptr(std::get<0>(t));
1823 mooseAssert(
node !=
nullptr,
1824 "libMesh::BoundaryInfo::build_node_list() returned an ID for a non-existing node");
1825 auto bc_id = std::get<1>(t);
1826 periodic_nodes.emplace_back(
node, bc_id);
1830 std::sort(periodic_nodes.begin(),
1831 periodic_nodes.end(),
1833 {
return a.second > b.second; });
1836 using KDTreeType = nanoflann::KDTreeSingleIndexAdaptor<
1837 nanoflann::L2_Simple_Adaptor<Real, PointListAdaptor<PeriodicNodeInfo>,
Real, std::size_t>,
1841 const unsigned int max_leaf_size = 20;
1844 auto kd_tree = std::make_unique<KDTreeType>(
1845 LIBMESH_DIM, point_list, nanoflann::KDTreeSingleIndexAdaptorParams(max_leaf_size));
1846 mooseAssert(kd_tree !=
nullptr,
"KDTree was not properly initialized.");
1847 kd_tree->buildIndex();
1851 std::vector<nanoflann::ResultItem<std::size_t, Real>> ret_matches;
1855 BoundaryID current_bc_id = BoundaryInfo::invalid_id;
1856 for (
auto & pair : periodic_nodes)
1859 if (pair.second != current_bc_id)
1861 current_bc_id = pair.second;
1862 periodic = pbs->
boundary(current_bc_id);
1872 ret_matches.clear();
1875 const auto id = pair.first->id();
1881 kd_tree->radiusSearch(&(search_point)(0),
libMesh::TOLERANCE, ret_matches, search_params);
1882 for (
auto & match_pair : ret_matches)
1884 const auto & match = periodic_nodes[match_pair.first];
1887 periodic_node_map.emplace(
id, match.first->id());
1894 unsigned int var_number,
1897 TIME_SECTION(
"buildPeriodicNodeSets", 5);
1899 periodic_node_sets.clear();
1902 for (
const auto & t :
getMesh().get_boundary_info().build_node_list())
1904 auto node_id = std::get<0>(t);
1905 auto bc_id = std::get<1>(t);
1908 if (periodic_node_sets.find(bc_id) != periodic_node_sets.end())
1909 periodic_node_sets[bc_id].insert(node_id);
1914 periodic_node_sets[bc_id].insert(node_id);
1922 TIME_SECTION(
"detectOrthogonalDimRanges", 5);
1932 for (
const auto &
node :
getMesh().node_ptr_range())
1938 min[i] = (*node)(i);
1940 max[i] = (*node)(i);
1948 std::vector<bool> extreme_matches(8,
false);
1949 std::vector<unsigned int> comp_map(3);
1950 for (
const auto &
node :
getMesh().node_ptr_range())
1953 unsigned int coord_match = 0;
1969 if (coord_match == LIBMESH_DIM)
1972 extreme_matches[comp_map[
X] * 4 + comp_map[
Y] * 2 + comp_map[
Z]] =
true;
1977 this->
comm().
max(extreme_matches);
1978 if (std::count(extreme_matches.begin(), extreme_matches.end(),
true) == (1 <<
dim))
1996 TIME_SECTION(
"detectPairedSidesets", 5);
2008 const Point minus_x(-1, 0, 0), plus_x(1, 0, 0), minus_y(0, -1, 0), plus_y(0, 1, 0),
2009 minus_z(0, 0, -1), plus_z(0, 0, 1);
2015 std::vector<std::set<BoundaryID>> minus_x_ids(
dim), plus_x_ids(
dim), minus_y_ids(
dim),
2016 plus_y_ids(
dim), minus_z_ids(
dim), plus_z_ids(
dim);
2018 std::vector<std::unique_ptr<FEBase>> fe_faces(
dim);
2019 std::vector<std::unique_ptr<libMesh::QGauss>> qfaces(
dim);
2020 for (
unsigned side_dim = 0; side_dim <
dim; ++side_dim)
2028 fe_faces[side_dim]->attach_quadrature_rule(qfaces[side_dim].
get());
2033 std::vector<boundary_id_type> face_ids;
2038 unsigned int side_dim =
elem->
dim() - 1;
2039 const std::vector<Point> & normals = fe_faces[side_dim]->get_normals();
2042 for (
unsigned int s = 0; s <
elem->
n_sides(); s++)
2049 fe_faces[side_dim]->reinit(
elem, s);
2059 minus_x_ids[side_dim].insert(face_ids.begin(), face_ids.end());
2061 plus_x_ids[side_dim].insert(face_ids.begin(), face_ids.end());
2065 minus_y_ids[side_dim].insert(face_ids.begin(), face_ids.end());
2067 plus_y_ids[side_dim].insert(face_ids.begin(), face_ids.end());
2071 minus_z_ids[side_dim].insert(face_ids.begin(), face_ids.end());
2073 plus_z_ids[side_dim].insert(face_ids.begin(), face_ids.end());
2090 std::vector<std::pair<boundary_id_type, boundary_id_type>> vecdata;
2092 for (
unsigned side_dim = 0; side_dim <
dim; ++side_dim)
2096 for (
auto bd = minus_x_ids[side_dim].begin(); bd != minus_x_ids[side_dim].end(); bd++)
2097 vecdata.emplace_back(side_dim * 6 + 0, *bd);
2099 for (
auto bd = plus_x_ids[side_dim].begin(); bd != plus_x_ids[side_dim].end(); bd++)
2100 vecdata.emplace_back(side_dim * 6 + 1, *bd);
2102 for (
auto bd = minus_y_ids[side_dim].begin(); bd != minus_y_ids[side_dim].end(); bd++)
2103 vecdata.emplace_back(side_dim * 6 + 2, *bd);
2105 for (
auto bd = plus_y_ids[side_dim].begin(); bd != plus_y_ids[side_dim].end(); bd++)
2106 vecdata.emplace_back(side_dim * 6 + 3, *bd);
2108 for (
auto bd = minus_z_ids[side_dim].begin(); bd != minus_z_ids[side_dim].end(); bd++)
2109 vecdata.emplace_back(side_dim * 6 + 4, *bd);
2111 for (
auto bd = plus_z_ids[side_dim].begin(); bd != plus_z_ids[side_dim].end(); bd++)
2112 vecdata.emplace_back(side_dim * 6 + 5, *bd);
2118 for (
auto pair = vecdata.begin(); pair != vecdata.end(); pair++)
2121 auto side_dim = pair->first / 6;
2122 auto side = pair->first % 6;
2127 minus_x_ids[side_dim].insert(pair->second);
2130 plus_x_ids[side_dim].insert(pair->second);
2133 minus_y_ids[side_dim].insert(pair->second);
2136 plus_y_ids[side_dim].insert(pair->second);
2139 minus_z_ids[side_dim].insert(pair->second);
2142 plus_z_ids[side_dim].insert(pair->second);
2151 for (
unsigned side_dim = 0; side_dim <
dim; ++side_dim)
2155 if (minus_x_ids[side_dim].size() == 1 && plus_x_ids[side_dim].size() == 1)
2157 std::make_pair(*(minus_x_ids[side_dim].begin()), *(plus_x_ids[side_dim].begin())));
2160 "For side dimension " + std::to_string(side_dim) +
2161 " we did not find paired boundaries (sidesets) in X due to the presence of " +
2162 std::to_string(minus_x_ids[side_dim].size()) +
" -X normal and " +
2163 std::to_string(plus_x_ids[side_dim].size()) +
" +X normal boundaries.");
2165 if (minus_y_ids[side_dim].size() == 1 && plus_y_ids[side_dim].size() == 1)
2167 std::make_pair(*(minus_y_ids[side_dim].begin()), *(plus_y_ids[side_dim].begin())));
2170 "For side dimension " + std::to_string(side_dim) +
2171 " we did not find paired boundaries (sidesets) in Y due to the presence of " +
2172 std::to_string(minus_y_ids[side_dim].size()) +
" -Y normal and " +
2173 std::to_string(plus_y_ids[side_dim].size()) +
" +Y normal boundaries.");
2175 if (minus_z_ids[side_dim].size() == 1 && plus_z_ids[side_dim].size() == 1)
2177 std::make_pair(*(minus_z_ids[side_dim].begin()), *(plus_z_ids[side_dim].begin())));
2180 "For side dimension " + std::to_string(side_dim) +
2181 " we did not find paired boundaries (sidesets) in Z due to the presence of " +
2182 std::to_string(minus_z_ids[side_dim].size()) +
" -Z normal and " +
2183 std::to_string(plus_z_ids[side_dim].size()) +
" +Z normal boundaries.");
2196 mooseAssert(
_mesh,
"The MeshBase has not been constructed");
2197 mooseAssert(component <
_bounds.size(),
"Requested dimension out of bounds");
2205 mooseAssert(
_mesh,
"The MeshBase has not been constructed");
2206 mooseAssert(component <
_bounds.size(),
"Requested dimension out of bounds");
2221 bool component_found =
false;
2222 for (
unsigned int component = 0; component <
dimension(); ++component)
2226 if (boundary_ids !=
nullptr &&
2227 ((boundary_ids->first == primary && boundary_ids->second == secondary) ||
2228 (boundary_ids->first == secondary && boundary_ids->second == primary)))
2231 component_found =
true;
2234 if (!component_found)
2235 mooseWarning(
"Could not find a match between boundary '",
2239 "' to set periodic boundary conditions for variable (index:",
2241 ") in either the X, Y or Z direction. The periodic dimension of the mesh for this " 2242 "variable will not be stored.");
2248 mooseAssert(component <
dimension(),
"Requested dimension out of bounds");
2259 for (
unsigned int i = 0; i <
dimension(); ++i)
2287 const std::pair<BoundaryID, BoundaryID> *
2291 mooseError(
"Trying to retrieve automatic paired mapping for a mesh that is not regular and " 2294 mooseAssert(component <
dimension(),
"Requested dimension out of bounds");
2308 std::map<ElemType, Elem *> canonical_elems;
2312 for (
const auto &
elem :
getMesh().element_ptr_range())
2316 if (canonical_elems.find(
type) ==
2317 canonical_elems.end())
2321 Elem * stored = canonical_elems[
type];
2328 for (
const auto & can_it : canonical_elems)
2346 for (
unsigned int side = 0; side <
elem->
n_sides(); side++)
2354 for (
unsigned int child = 0; child <
elem->
n_children(); ++child)
2355 for (
unsigned int side = 0; side <
elem->
n_sides();
2370 std::map<ElemType, std::pair<Elem *, unsigned int>> elems_and_max_p_level;
2372 for (
const auto &
elem :
getMesh().active_element_ptr_range())
2375 auto & [picked_elem, max_p_level] = elems_and_max_p_level[
type];
2383 std::vector<Point> volume_ref_points_coarse, volume_ref_points_fine, face_ref_points_coarse,
2384 face_ref_points_fine;
2385 std::vector<unsigned int> p_levels;
2387 for (
auto & [elem_type, elem_p_level_pair] : elems_and_max_p_level)
2389 auto & [moose_elem, max_p_level] = elem_p_level_pair;
2390 const auto dim = moose_elem->dim();
2393 assembly->
reinit(moose_elem);
2394 assembly->
reinit(moose_elem, 0);
2401 for (
const auto & nd : moose_elem->node_ref_range())
2410 const auto & face_phys_points = fe_face->get_xyz();
2411 fe_face->attach_quadrature_rule(qrule_face);
2414 volume_ref_points_coarse = qrule->get_points();
2415 fe_face->reinit(
elem, (
unsigned int)0);
2418 p_levels.resize(max_p_level + 1);
2419 std::iota(p_levels.begin(), p_levels.end(), 0);
2422 for (
const auto p_level : p_levels)
2424 mesh_refinement.uniformly_p_refine(1);
2426 volume_ref_points_fine = qrule->get_points();
2427 fe_face->reinit(
elem, (
unsigned int)0);
2430 const auto map_key = std::make_pair(elem_type, p_level);
2436 auto fill_maps = [
this](
const auto & coarse_ref_points,
2437 const auto & fine_ref_points,
2441 mapPoints(fine_ref_points, coarse_ref_points, refine_map);
2442 mapPoints(coarse_ref_points, fine_ref_points, coarsen_map);
2446 volume_ref_points_coarse, volume_ref_points_fine, volume_coarsen_map, volume_refine_map);
2447 fill_maps(face_ref_points_coarse, face_ref_points_fine, face_coarsen_map, face_refine_map);
2450 volume_ref_points_fine.swap(volume_ref_points_coarse);
2451 face_ref_points_fine.swap(face_ref_points_coarse);
2459 TIME_SECTION(
"buildRefinementAndCoarseningMaps", 5,
"Building Refinement And Coarsening Maps");
2474 TIME_SECTION(
"buildRefinementMap", 5,
"Building Refinement Map");
2478 mooseAssert(parent_side == child_side,
2479 "Parent side must match child_side if not passing a specific child!");
2481 std::pair<int, ElemType> the_pair(parent_side,
elem.
type());
2484 mooseError(
"Already built a qp refinement map!");
2486 std::vector<std::pair<unsigned int, QpMap>> coarsen_map;
2489 &
elem, qrule, qrule_face, refinement_map, coarsen_map, parent_side, child, child_side);
2493 std::pair<int, int> child_pair(child, child_side);
2499 mooseError(
"Already built a qp refinement map!");
2501 std::vector<std::pair<unsigned int, QpMap>> coarsen_map;
2502 std::vector<std::vector<QpMap>> & refinement_map =
2505 &
elem, qrule, qrule_face, refinement_map, coarsen_map, parent_side, child, child_side);
2509 const std::vector<std::vector<QpMap>> &
2514 mooseAssert(parent_side == child_side,
2515 "Parent side must match child_side if not passing a specific child!");
2517 std::pair<int, ElemType> the_pair(parent_side,
elem.
type());
2520 mooseError(
"Could not find a suitable qp refinement map!");
2526 std::pair<int, int> child_pair(child, child_side);
2532 mooseError(
"Could not find a suitable qp refinement map!");
2548 TIME_SECTION(
"buildCoarseningMap", 5,
"Building Coarsening Map");
2550 std::pair<int, ElemType> the_pair(input_side,
elem.
type());
2553 mooseError(
"Already built a qp coarsening map!");
2555 std::vector<std::vector<QpMap>> refinement_map;
2556 std::vector<std::pair<unsigned int, QpMap>> & coarsen_map =
2563 &
elem, qrule, qrule_face, refinement_map, coarsen_map, input_side, -1, input_side);
2573 const std::vector<std::pair<unsigned int, QpMap>> &
2576 std::pair<int, ElemType> the_pair(input_side,
elem.
type());
2579 mooseError(
"Could not find a suitable qp refinement map!");
2586 const std::vector<Point> & to,
2587 std::vector<QpMap> & qp_map)
2589 unsigned int n_from = from.size();
2590 unsigned int n_to = to.size();
2592 qp_map.resize(n_from);
2594 for (
unsigned int i = 0; i < n_from; ++i)
2596 const Point & from_point = from[i];
2598 QpMap & current_map = qp_map[i];
2600 for (
unsigned int j = 0; j < n_to; ++j)
2602 const Point & to_point = to[j];
2608 current_map.
_from = i;
2609 current_map.
_to = j;
2619 std::vector<std::vector<QpMap>> & refinement_map,
2620 std::vector<std::pair<unsigned int, QpMap>> & coarsen_map,
2625 TIME_SECTION(
"findAdaptivityQpMaps", 5);
2630 unsigned int dim = template_elem->
dim();
2633 for (
unsigned int i = 0; i < template_elem->
n_nodes(); ++i)
2638 for (
unsigned int i = 0; i < template_elem->
n_nodes(); ++i)
2643 const std::vector<Point> & q_points_volume = fe->get_xyz();
2647 const std::vector<Point> & q_points_face = fe_face->get_xyz();
2649 fe->attach_quadrature_rule(&qrule);
2650 fe_face->attach_quadrature_rule(&qrule_face);
2653 const std::vector<Point> * q_points;
2655 if (parent_side != -1)
2657 fe_face->reinit(
elem, parent_side);
2658 q_points = &q_points_face;
2663 q_points = &q_points_volume;
2666 std::vector<Point> parent_ref_points;
2670 mesh_refinement.uniformly_refine(1);
2675 std::map<unsigned int, std::vector<Point>> child_to_ref_points;
2679 refinement_map.resize(n_children);
2681 std::vector<unsigned int> children;
2684 children.push_back(child);
2687 children.resize(n_children);
2688 for (
unsigned int child = 0; child < n_children; ++child)
2689 children[child] = child;
2692 for (
unsigned int i = 0; i < children.size(); ++i)
2694 unsigned int child = children[i];
2701 if (child_side != -1)
2703 fe_face->reinit(child_elem, child_side);
2704 q_points = &q_points_face;
2708 fe->reinit(child_elem);
2709 q_points = &q_points_volume;
2712 std::vector<Point> child_ref_points;
2715 child_to_ref_points[child] = child_ref_points;
2717 std::vector<QpMap> & qp_map = refinement_map[child];
2720 mapPoints(child_ref_points, parent_ref_points, qp_map);
2723 coarsen_map.resize(parent_ref_points.size());
2726 for (
unsigned int child = 0; child < n_children; child++)
2731 std::vector<Point> & child_ref_points = child_to_ref_points[child];
2733 std::vector<QpMap> qp_map;
2736 mapPoints(parent_ref_points, child_ref_points, qp_map);
2739 for (
unsigned int parent_qp = 0; parent_qp < parent_ref_points.size(); ++parent_qp)
2741 std::pair<unsigned int, QpMap> & child_and_map = coarsen_map[parent_qp];
2742 unsigned int & closest_child = child_and_map.first;
2743 QpMap & closest_map = child_and_map.second;
2745 QpMap & current_map = qp_map[parent_qp];
2749 closest_child = child;
2750 closest_map = current_map;
2761 TIME_SECTION(
"changeBoundaryId", 6);
2775 std::vector<boundary_id_type> old_ids;
2781 for (
unsigned int s = 0; s != n_sides; ++s)
2784 if (std::find(old_ids.begin(), old_ids.end(), old_id) != old_ids.end())
2786 std::vector<boundary_id_type> new_ids(old_ids);
2787 std::replace(new_ids.begin(), new_ids.end(), old_id, new_id);
2819 mooseError(
"MooseMesh::clone() is no longer supported, use MooseMesh::safeClone() instead.");
2850 std::unique_ptr<MeshBase>
2853 std::unique_ptr<MeshBase>
mesh;
2855 mesh = buildTypedMesh<DistributedMesh>(
dim);
2857 mesh = buildTypedMesh<ReplicatedMesh>(
dim);
2865 _mesh = std::move(mesh_base);
2882 mooseError(
"You cannot use the mesh splitter capability with DistributedMesh!");
2884 TIME_SECTION(
"init", 2);
2899 TIME_SECTION(
"readRecoveredMesh", 2);
2917 if (getParam<bool>(
"build_all_side_lowerd_mesh"))
2931 const Real abs_zero = 1e-12;
2935 for (
unsigned int dim = LIBMESH_DIM;
dim >= 1; --
dim)
2950 return *elem_dims.begin();
2952 unsigned short dim = 0;
2954 const std::set<SubdomainID> subdomain_ids_set(subdomain_ids.begin(), subdomain_ids.end());
2963 std::vector<BoundaryID>
2966 std::vector<BoundaryID> ids;
2971 const std::set<BoundaryID> &
2986 std::vector<unsigned short int> & sl,
2987 std::vector<boundary_id_type> & il)
2989 #ifdef LIBMESH_ENABLE_DEPRECATED 2990 mooseDeprecated(
"The version of MooseMesh::buildSideList() taking three arguments is " 2991 "deprecated, call the version that returns a vector of tuples instead.");
2997 mooseError(
"The version of MooseMesh::buildSideList() taking three " 2998 "arguments is not available in your version of libmesh, call the " 2999 "version that returns a vector of tuples instead.");
3003 std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>>
3009 std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>>
3024 return getMesh().local_nodes_begin();
3030 return getMesh().local_nodes_end();
3033 MeshBase::const_node_iterator
3036 return getMesh().local_nodes_begin();
3039 MeshBase::const_node_iterator
3042 return getMesh().local_nodes_end();
3045 MeshBase::element_iterator
3048 return getMesh().active_local_elements_begin();
3051 const MeshBase::element_iterator
3054 return getMesh().active_local_elements_end();
3057 MeshBase::const_element_iterator
3060 return getMesh().active_local_elements_begin();
3063 const MeshBase::const_element_iterator
3066 return getMesh().active_local_elements_end();
3096 mooseDeprecated(
"MooseMesh::elem() is deprecated, please use MooseMesh::elemPtr() instead");
3103 mooseDeprecated(
"MooseMesh::elem() is deprecated, please use MooseMesh::elemPtr() instead");
3141 mooseError(
"We don't have any right to tell the libmesh mesh that it *is* prepared. Only a " 3142 "call to prepare_for_use should tell us that");
3147 _mesh->set_isnt_prepared();
3165 const std::set<SubdomainID> &
3171 const std::set<BoundaryID> &
3177 const std::set<BoundaryID> &
3183 const std::set<BoundaryID> &
3197 std::unique_ptr<std::map<BoundaryID, RealVectorValue>> boundary_map)
3205 mooseDeprecated(
"setBoundaryToNormalMap(std::map<BoundaryID, RealVectorValue> * boundary_map) is " 3206 "deprecated, use the unique_ptr version instead");
3235 const std::set<unsigned int> &
3241 const std::vector<Real> &
3255 template <
typename T>
3256 struct extra_ghost_elem_inserter
3258 using iterator_category = std::output_iterator_tag;
3259 using value_type = T;
3263 void operator=(
const Elem * e) {
mesh.add_extra_ghost_elem(const_cast<Elem *>(e)); }
3269 extra_ghost_elem_inserter &
operator++() {
return *
this; }
3271 extra_ghost_elem_inserter
operator++(
int) {
return extra_ghost_elem_inserter(*
this); }
3277 extra_ghost_elem_inserter &
operator*() {
return *
this; }
3293 struct CompareElemsByLevel
3295 bool operator()(
const Elem * a,
const Elem * b)
const 3299 const unsigned int al = a->
level(), bl = b->
level();
3302 return (al == bl) ? aid < bid : al < bl;
3318 TIME_SECTION(
"GhostGhostedBoundaries", 3);
3320 parallel_object_only();
3330 std::set<const Elem *, CompareElemsByLevel> boundary_elems_to_ghost;
3331 std::set<Node *> connected_nodes_to_ghost;
3337 auto elem_id = std::get<0>(t);
3338 auto bc_id = std::get<2>(t);
3344 #ifdef LIBMESH_ENABLE_AMR 3350 parent = parent->
parent();
3358 boundary_elems_to_ghost.insert(felem);
3366 for (
unsigned int n = 0; n < felem->n_nodes(); ++n)
3367 connected_nodes_to_ghost.insert(const_cast<Node *>(felem->node_ptr(n)));
3373 const auto prior_ghost_elems =
mesh.extra_ghost_elems();
3376 connected_nodes_to_ghost.begin(),
3377 connected_nodes_to_ghost.end(),
3378 extra_ghost_elem_inserter<Node>(
mesh));
3381 boundary_elems_to_ghost.begin(),
3382 boundary_elems_to_ghost.end(),
3383 extra_ghost_elem_inserter<Elem>(
mesh));
3385 const auto & current_ghost_elems =
mesh.extra_ghost_elems();
3387 std::set_difference(current_ghost_elems.begin(),
3388 current_ghost_elems.end(),
3389 prior_ghost_elems.begin(),
3390 prior_ghost_elems.end(),
3423 Real inflation_amount = inflation_multiplier * (bbox.
max() - bbox.
min()).
norm();
3424 Point inflation(inflation_amount, inflation_amount, inflation_amount);
3426 bbox.first -= inflation;
3427 bbox.second += inflation;
3445 mooseAssert(
_mesh,
"Mesh hasn't been created");
3452 mooseAssert(
_mesh,
"Mesh hasn't been created");
3464 const std::vector<dof_id_type> &
3467 std::map<boundary_id_type, std::vector<dof_id_type>>::const_iterator it =
3477 static const std::vector<dof_id_type> empty_vec;
3484 mooseError(
"Unable to nodeset ID: ", nodeset_id,
'.');
3491 const std::set<BoundaryID> &
3497 mooseError(
"Unable to find subdomain ID: ", subdomain_id,
'.');
3499 return it->second.boundary_ids;
3502 std::set<BoundaryID>
3506 std::set<BoundaryID> boundary_ids(bnd_ids.begin(), bnd_ids.end());
3507 std::unordered_map<SubdomainID, std::set<BoundaryID>>::const_iterator it =
3510 boundary_ids.insert(it->second.begin(), it->second.end());
3512 return boundary_ids;
3515 std::set<SubdomainID>
3518 std::set<SubdomainID> subdomain_ids;
3520 if (data.boundary_ids.find(bid) != data.boundary_ids.end())
3521 subdomain_ids.insert(sub_id);
3523 return subdomain_ids;
3526 std::set<SubdomainID>
3529 std::set<SubdomainID> subdomain_ids;
3531 if (it.second.find(bid) != it.second.end())
3532 subdomain_ids.insert(it.first);
3534 return subdomain_ids;
3537 std::set<SubdomainID>
3542 if (it.second.find(bid) != it.second.end())
3543 subdomain_ids.insert(it.first);
3545 return subdomain_ids;
3548 const std::set<SubdomainID> &
3554 mooseError(
"Unable to find subdomain ID: ", subdomain_id,
'.');
3556 return it->second.neighbor_subs;
3562 bool found_node =
false;
3565 if (it.second.find(node_id) != it.second.end())
3577 bool found_node =
false;
3578 std::map<boundary_id_type, std::set<dof_id_type>>::const_iterator it =
_bnd_node_ids.find(bnd_id);
3580 if (it->second.find(node_id) != it->second.end())
3588 bool found_elem =
false;
3591 if (it.second.find(elem_id) != it.second.end())
3603 bool found_elem =
false;
3606 if (it->second.find(elem_id) != it->second.end())
3617 " with DistributedMesh!\n",
3618 "Consider specifying parallel_type = 'replicated' in your input file\n",
3619 "to prevent it from being run with DistributedMesh.");
3637 bool use_distributed_mesh,
3642 switch (partitioner)
3646 if (use_distributed_mesh)
3647 partitioner =
"parmetis";
3649 partitioner =
"metis";
3663 if (!params.
isParamValid(
"centroid_partitioner_direction"))
3665 "centroid_partitioner_direction",
3666 "If using the centroid partitioner you _must_ specify centroid_partitioner_direction!");
3670 if (direction ==
"x")
3673 else if (direction ==
"y")
3676 else if (direction ==
"z")
3679 else if (direction ==
"radial")
3708 bool mesh_has_second_order_elements =
false;
3710 if ((*it)->default_order() ==
SECOND)
3712 mesh_has_second_order_elements =
true;
3717 comm().
max(mesh_has_second_order_elements);
3718 return mesh_has_second_order_elements;
3727 std::unique_ptr<libMesh::PointLocatorBase>
3736 mooseAssert(!Threads::in_threads,
3737 "This routine has not been implemented for threads. Please query this routine before " 3738 "a threaded region or contact a MOOSE developer to discuss.");
3741 using Keytype = std::pair<const Elem *, unsigned short int>;
3744 std::vector<std::tuple<dof_id_type, unsigned short int, boundary_id_type>> side_list =
3746 std::map<Keytype, std::set<boundary_id_type>> side_map;
3747 for (
auto & [elem_id, side, bc_id] : side_list)
3750 Keytype key(
elem, side);
3751 auto & bc_set = side_map[key];
3752 bc_set.insert(bc_id);
3766 auto begin =
getMesh().active_elements_begin();
3767 auto end =
getMesh().active_elements_end();
3777 for (
unsigned int side = 0; side <
elem->
n_sides(); ++side)
3788 "If the neighbor is coarser than the element, we expect that the neighbor must " 3798 std::set<boundary_id_type> & boundary_ids = fi.boundaryIDs();
3799 boundary_ids.clear();
3805 fi.computeBoundaryCoefficients();
3809 auto lit = side_map.find(Keytype(&fi.elem(), fi.elemSideID()));
3810 if (lit != side_map.end())
3811 boundary_ids.insert(lit->second.begin(), lit->second.end());
3813 if (fi.neighborPtr())
3815 auto rit = side_map.find(Keytype(fi.neighborPtr(), fi.neighborSideID()));
3816 if (rit != side_map.end())
3817 boundary_ids.insert(rit->second.begin(), rit->second.end());
3828 const Elem *
const elem = &fi.elem();
3829 const auto side = fi.elemSideID();
3835 mooseAssert(pair_it.second,
"We should be adding unique FaceInfo objects.");
3839 if (fi.elem().processor_id() == this->
processor_id() ||
3840 (fi.neighborPtr() && (fi.neighborPtr()->processor_id() == this->
processor_id())))
3845 if (ei.second.elem()->processor_id() == this->
processor_id())
3858 mooseAssert(it->second,
3859 "For some reason, the FaceInfo object is NULL! Try calling " 3860 "`buildFiniteVolumeInfo()` before using this accessor!");
3875 mooseError(
"Trying to compute face- and elem-info coords when the information is dirty");
3880 const SubdomainID elem_subdomain_id = fi.elemSubdomainID();
3881 const SubdomainID neighbor_subdomain_id = fi.neighborSubdomainID();
3884 *
this, elem_subdomain_id, fi.faceCentroid(), fi.faceCoord(), neighbor_subdomain_id);
3889 *
this, ei.second.subdomain_id(), ei.second.centroid(), ei.second.coordFactor());
3904 "EDGE EDGE2 EDGE3 EDGE4 QUAD QUAD4 QUAD8 QUAD9 TRI3 TRI6 HEX HEX8 HEX20 HEX27 TET4 TET10 " 3905 "PRISM6 PRISM15 PRISM18 PYRAMID5 PYRAMID13 PYRAMID14");
3914 _mesh->allow_remote_element_removal(allow_remote_element_removal);
3916 if (!allow_remote_element_removal)
3928 mooseError(
"Cannot delete remote elements because we have not yet attached a MeshBase");
3930 _mesh->allow_remote_element_removal(
true);
3932 _mesh->delete_remote_elements();
3939 !Threads::in_threads,
3940 "Performing writes to faceInfo variable association maps. This must be done unthreaded!");
3944 auto face_lambda = [
this](
const SubdomainID elem_subdomain_id,
3947 std::vector<std::vector<FaceInfo::VarFaceNeighbors>> & face_type_vector)
3950 const auto & variables = sys.getVariables(0);
3952 for (
const auto & var : variables)
3954 const unsigned int var_num = var->number();
3955 const unsigned int sys_num = var->sys().number();
3956 std::set<SubdomainID> var_subdomains = var->blockIDs();
3966 bool var_defined_elem = var_subdomains.find(elem_subdomain_id) != var_subdomains.end();
3967 bool var_defined_neighbor =
3968 var_subdomains.find(neighbor_subdomain_id) != var_subdomains.end();
3969 if (var_defined_elem && var_defined_neighbor)
3971 else if (!var_defined_elem && !var_defined_neighbor)
3976 if (var_defined_elem)
3978 else if (var_defined_neighbor)
3990 const SubdomainID elem_subdomain_id = face.elemSubdomainID();
3991 const SubdomainID neighbor_subdomain_id = face.neighborSubdomainID();
3993 auto & face_type_vector = face.faceType();
3995 face_type_vector.clear();
3996 face_type_vector.resize(num_eqs);
4000 face_lambda(elem_subdomain_id,
4001 neighbor_subdomain_id,
4006 face_lambda(elem_subdomain_id,
4007 neighbor_subdomain_id,
4016 mooseAssert(!Threads::in_threads,
4017 "Performing writes to elemInfo dof indices. This must be done unthreaded!");
4019 auto elem_lambda = [](
const ElemInfo & elem_info,
4021 std::vector<std::vector<dof_id_type>> & dof_vector)
4023 if (sys.nFVVariables())
4026 const auto & variables = sys.getVariables(0);
4028 for (
const auto & var : variables)
4031 const auto & var_subdomains = var->blockIDs();
4034 if (var_subdomains.find(elem_info.
subdomain_id()) != var_subdomains.end())
4036 std::vector<dof_id_type> indices;
4037 var->dofMap().dof_indices(elem_info.
elem(), indices, var->number());
4038 mooseAssert(indices.size() == 1,
"We expect to have only one dof per element!");
4039 dof_vector[sys.number()][var->number()] = indices[0];
4051 auto & elem_info = ei_pair.second;
4055 dof_vector.resize(num_eqs);
4079 TIME_SECTION(
"setCoordSystem", 5,
"Setting Coordinate System");
4082 const std::string param_name =
isParamValid(
"coord_block") ?
"coord_block" :
"block";
4083 mooseWarning(
"Supplied blocks in the 'setCoordSystem' method do not match the value of the " 4086 "' parameter. Did you provide different parameter values for 'Mesh/",
4088 "' and 'Problem/block'?. We will honor the parameter value from 'Mesh/",
4092 "If we are arriving here due to a bad specification in the Problem block, then we " 4093 "should have already set our coordinate system subdomains from the Mesh block");
4097 mooseError(
"Supplied coordinate systems in the 'setCoordSystem' method do not match the value " 4098 "of the 'Mesh/coord_type' parameter. Did you provide different parameter values for " 4099 "'coord_type' to 'Mesh' and 'Problem'?");
4104 for (
const auto & sub_name :
blocks)
4107 subdomains.insert(sub_id);
4110 if (coord_sys.
size() <= 1)
4113 const auto coord_type = coord_sys.
size() == 0
4115 : Moose::stringToEnum<Moose::CoordinateSystemType>(coord_sys[0]);
4116 for (
const auto sid : subdomains)
4122 mooseError(
"Number of blocks and coordinate systems does not match.");
4128 Moose::stringToEnum<Moose::CoordinateSystemType>(coord_sys[i]);
4132 for (
const auto & sid : subdomains)
4135 "' does not have a coordinate system specified.");
4148 return (*it).second;
4150 mooseError(
"Requested subdomain ", sid,
" does not exist.");
4158 bool result = std::all_of(
4162 typename std::unordered_map<SubdomainID, Moose::CoordinateSystemType>::const_reference
4163 item) {
return (item.second == unique_system); });
4165 mooseError(
"The unique coordinate system of the mesh was requested by the mesh contains " 4166 "multiple blocks with different coordinate systems");
4169 mooseError(
"General axisymmetric coordinate axes are being used, and it is currently " 4170 "conservatively assumed that in this case there is no unique coordinate system.");
4172 return unique_system;
4175 const std::map<SubdomainID, Moose::CoordinateSystemType> &
4191 const std::vector<SubdomainName> &
blocks,
4192 const std::vector<std::pair<Point, RealVectorValue>> & axes)
4195 mooseAssert(
blocks.size() == axes.size(),
"Blocks and axes vectors must be the same length.");
4199 const auto it =
_coord_sys.find(subdomain_id);
4203 "' has not set a coordinate system. Make sure to call setCoordSystem() before " 4204 "setGeneralAxisymmetricCoordAxes().");
4209 const auto direction = axes[i].second;
4210 if (direction.is_zero())
4211 mooseError(
"Only nonzero vectors may be supplied for RZ directions.");
4214 std::make_pair(axes[i].first, direction.unit());
4219 "' was provided in setGeneralAxisymmetricCoordAxes(), but the coordinate system " 4220 "for this block is not 'RZ'.");
4226 for (
const auto subdomain_id : all_subdomain_ids)
4231 "' was specified to use the 'RZ' coordinate system but was not given in " 4232 "setGeneralAxisymmetricCoordAxes().");
4237 const std::pair<Point, RealVectorValue> &
4242 return (*it).second;
4244 mooseError(
"Requested subdomain ", subdomain_id,
" does not exist.");
4266 mooseError(
"getAxisymmetricRadialCoord() should not be called if " 4267 "setGeneralAxisymmetricCoordAxes() has been called.");
4278 for (
const auto &
elem :
getMesh().element_ptr_range())
4283 " which contains 3D elements.");
4285 mooseError(
"An RSPHERICAL coordinate system was requested for subdomain " +
4308 std::map<SubdomainName, SubdomainID> subdomain;
4312 if (!sub_name.empty() && subdomain.count(sub_name) > 0)
4315 " is used for both subdomain with ID=",
4316 subdomain[sub_name],
4319 ", Please rename one of them!");
4321 subdomain[sub_name] = sbd_id;
4325 const std::vector<QpMap> &
4328 const std::map<std::pair<ElemType, unsigned int>, std::vector<QpMap>> & map)
const 4332 return libmesh_map_find(map,
4336 const std::vector<QpMap> &
4339 const std::map<std::pair<ElemType, unsigned int>, std::vector<QpMap>> & map)
const 4342 "These are the conditions that should be met for requesting a coarsening map");
4346 const std::vector<QpMap> &
4352 const std::vector<QpMap> &
4358 const std::vector<QpMap> &
4364 const std::vector<QpMap> &
4373 return _mesh->skip_noncritical_partitioning();
ParallelType _parallel_type
Can be set to DISTRIBUTED, REPLICATED, or DEFAULT.
static InputParameters validParams()
Typical "Moose-style" constructor and copy constructor.
virtual bnd_node_iterator bndNodesEnd()
virtual bnd_elem_iterator bndElemsEnd()
std::vector< std::vector< Real > > _bounds
The bounds in each dimension of the mesh for regular orthogonal meshes.
std::set< Node * > _semilocal_node_list
Used for generating the semilocal node range.
void remove_id(boundary_id_type id, bool global=false)
std::map< dof_id_type, Node * > _quadrature_nodes
const std::vector< QpMap > & getPCoarseningSideMap(const Elem &elem) const
Get the map describing for each side quadrature point (qp) on the coarse level which qp on the previo...
virtual Real getMaxInDimension(unsigned int component) const
static const std::string & checkpointSuffix()
The file suffix for the checkpoint mesh.
bool _node_to_elem_map_built
std::unique_ptr< libMesh::NodeRange > _active_node_range
MetaPhysicL::DualNumber< V, D, asd > abs(const MetaPhysicL::DualNumber< V, D, asd > &a)
std::vector< Node * > _extreme_nodes
A vector containing the nodes at the corners of a regular orthogonal mesh.
Node * addQuadratureNode(const Elem *elem, const unsigned short int side, const unsigned int qp, BoundaryID bid, const Point &point)
Adds a fictitious "QuadratureNode".
std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > > buildSideList()
As above, but uses the non-deprecated std::tuple interface.
const std::set< BoundaryID > & meshNodesetIds() const
Returns a read-only reference to the set of nodesets currently present in the Mesh.
void buildElemIDInfo()
Build extra data for faster access to the information of extra element integers.
std::vector< FaceInfo > _all_face_info
FaceInfo object storing information for face based loops.
std::unique_ptr< FEGenericBase< Real > > build(const unsigned int dim, const FEType &fet)
void allgather(const T &send_data, std::vector< T, A > &recv_data) const
std::vector< const FaceInfo * > _face_info
Holds only those FaceInfo objects that have processor_id equal to this process's id, e.g.
bool allowRemoteElementRemoval() const
Whether we are allow remote element removal.
virtual Real getMinInDimension(unsigned int component) const
Returns the min or max of the requested dimension respectively.
bool elemHasFaceInfo(const Elem &elem, const Elem *const neighbor)
This function infers based on elements if the faceinfo between them belongs to the element or not...
libMesh::ConstElemRange * getActiveLocalElementRange()
Return pointers to range objects for various types of ranges (local nodes, boundary elems...
virtual void read(const std::string &name, void *mesh_data=nullptr, bool skip_renumber_nodes_and_elements=false, bool skip_find_neighbors=false)=0
virtual void onMeshChanged()
Declares a callback function that is executed at the conclusion of meshChanged(). ...
bool prepared() const
Setter/getter for whether the mesh is prepared.
void needsPrepareForUse()
If this method is called, we will call libMesh's prepare_for_use method when we call Moose's prepare ...
const std::set< boundary_id_type > & get_side_boundary_ids() const
const std::set< BoundaryID > & getBoundaryIDs() const
Returns a const reference to a set of all user-specified boundary IDs.
bool _is_nemesis
True if a Nemesis Mesh was read in.
std::vector< SubdomainName > _provided_coord_blocks
Set for holding user-provided coordinate system type block names.
virtual MooseMesh & clone() const
Clone method.
const Elem * parent() const
const std::vector< QpMap > & getPCoarseningMapHelper(const Elem &elem, const std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap >> &) const
bool isCustomPartitionerRequested() const
Setter and getter for _custom_partitioner_requested.
bool _need_ghost_ghosted_boundaries
A parallel mesh generator such as DistributedRectilinearMeshGenerator already make everything ready...
A class for creating restricted objects.
bool isUltimateMaster() const
Whether or not this app is the ultimate master app.
unsigned int _uniform_refine_level
The level of uniform refinement requested (set to zero if AMR is disabled)
virtual Node *& set_node(const unsigned int i)
const std::vector< QpMap > & getPRefinementMapHelper(const Elem &elem, const std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap >> &) const
unsigned int n_systems() const
std::vector< dof_id_type > _min_ids
Minimum integer ID for each extra element integer.
Helper class for sorting Boundary Nodes so that we always get the same order of application for bound...
libMesh::QBase *const & writeableQRule()
Returns the reference to the current quadrature being used.
virtual unique_id_type parallel_max_unique_id() const=0
std::unordered_set< dof_id_type > getBoundaryActiveSemiLocalElemIds(BoundaryID bid) const
Return all ids of elements which have a side which is part of a sideset.
auto norm() const -> decltype(std::norm(Real()))
std::string & nodeset_name(boundary_id_type id)
const MooseUnits & lengthUnit() const
void checkDuplicateSubdomainNames()
Loop through all subdomain IDs and check if there is name duplication used for the subdomains with sa...
const unsigned int invalid_uint
const std::set< BoundaryID > & getSubdomainBoundaryIds(const SubdomainID subdomain_id) const
Get the list of boundary ids associated with the given subdomain id.
void mooseDeprecated(Args &&... args) const
std::unique_ptr< PointLocatorBase > sub_point_locator() const
void build_node_list_from_side_list()
RealVectorValue _half_range
A convenience vector used to hold values in each dimension representing half of the range...
Keeps track of stuff related to assembling.
std::map< libMesh::ElemType, std::map< std::pair< int, int >, std::vector< std::vector< QpMap > > > > _elem_type_to_child_side_refinement_map
Holds mappings for "internal" child sides to parent volume. The second key is (child, child_side).
void setCoordData(const MooseMesh &other_mesh)
Set the coordinate system data to that of other_mesh.
const Elem * interior_parent() const
bool _finite_volume_info_dirty
virtual Elem * elemPtr(const dof_id_type i)
void allow_renumbering(bool allow)
The definition of the bnd_elem_iterator struct.
std::map< SubdomainID, Moose::CoordinateSystemType > & _coord_sys
Type of coordinate system per subdomain.
bool isBoundaryNode(dof_id_type node_id) const
Returns true if the requested node is in the list of boundary nodes, false otherwise.
face_info_iterator ownedFaceInfoBegin()
Iterators to owned faceInfo objects.
const std::map< dof_id_type, std::vector< dof_id_type > > & nodeToActiveSemilocalElemMap()
If not already created, creates a map from every node to all active semilocal elements to which they ...
std::vector< std::tuple< dof_id_type, unsigned short int, boundary_id_type > > buildActiveSideList() const
Calls BoundaryInfo::build_active_side_list.
IntRange< unsigned short > side_index_range() const
static void setPartitioner(MeshBase &mesh_base, MooseEnum &partitioner, bool use_distributed_mesh, const InputParameters ¶ms, MooseObject &context_obj)
Method for setting the partitioner on the passed in mesh_base object.
void skip_partitioning(bool skip)
void buildLowerDMesh()
Build lower-d mesh for all sides.
const std::set< BoundaryID > & meshSidesetIds() const
Returns a read-only reference to the set of sidesets currently present in the Mesh.
virtual std::unique_ptr< Elem > build_side_ptr(const unsigned int i)=0
std::unordered_map< const Elem *, unsigned short int > _lower_d_elem_to_higher_d_elem_side
const BoundaryID INVALID_BOUNDARY_ID
void cacheFVElementalDoFs() const
Cache the DoF indices for FV variables on each element.
static constexpr Real TOLERANCE
void cacheFaceInfoVariableOwnership() const
Cache if variables live on the elements connected by the FaceInfo objects.
bool _custom_partitioner_requested
const std::unordered_map< boundary_id_type, std::unordered_set< dof_id_type > > & getBoundariesToElems() const
Returns a map of boundaries to ids of elements on the boundary.
Moose::CoordinateSystemType getUniqueCoordSystem() const
Get the coordinate system from the mesh, it must be the same in all subdomains otherwise this will er...
static Point inverse_map(const unsigned int dim, const Elem *elem, const Point &p, const Real tolerance=TOLERANCE, const bool secure=true, const bool extra_checks=true)
std::map< dof_id_type, std::vector< dof_id_type > > _node_to_elem_map
A map of all of the current nodes to the elements that they are connected to.
bool isSemiLocal(Node *const node) const
Returns true if the node is semi-local.
unsigned int which_side_am_i(const Elem *e) const
virtual bool is_child_on_side(const unsigned int c, const unsigned int s) const=0
const Elem * getLowerDElem(const Elem *, unsigned short int) const
Returns a const pointer to a lower dimensional element that corresponds to a side of a higher dimensi...
std::unique_ptr< libMesh::StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement * > > _bnd_elem_range
RealVectorValue minPeriodicVector(unsigned int nonlinear_var_num, Point p, Point q) const
This function returns the minimum vector between two points on the mesh taking into account periodici...
const std::vector< std::pair< unsigned int, QpMap > > & getCoarseningMap(const Elem &elem, int input_side)
Get the coarsening map for a given element type.
std::unordered_map< boundary_id_type, std::unordered_set< dof_id_type > > _bnd_elem_ids
Map of set of elem IDs connected to each boundary.
void prepare_for_use(const bool skip_renumber_nodes_and_elements, const bool skip_find_neighbors)
RefinementState p_refinement_flag() const
bool _doing_p_refinement
Whether we have p-refinement (as opposed to h-refinement)
const Elem * elem() const
void determineUseDistributedMesh()
Determine whether to use a distributed mesh.
const std::vector< std::vector< QpMap > > & getRefinementMap(const Elem &elem, int parent_side, int child, int child_side)
Get the refinement map for a given element type.
const boundary_id_type side_id
const std::string & getBoundaryName(BoundaryID boundary_id)
Return the name of the boundary given the id.
void cacheChangedLists()
Cache information about what elements were refined and coarsened in the previous step.
bool isTranslatedPeriodic(unsigned int nonlinear_var_num, unsigned int component) const
Returns whether this generated mesh is periodic in the given dimension for the given variable...
void coordTransformFactor(const SubProblem &s, SubdomainID sub_id, const P &point, C &factor, SubdomainID neighbor_sub_id=libMesh::Elem::invalid_subdomain_id)
Computes a conversion multiplier for use when computing integraals for the current coordinate system ...
const Point & getPoint(const PointObject &item) const
get a Point reference from the PointData object at index idx in the list
void family_tree(std::vector< const Elem * > &family, bool reset=true) const
unsigned int side_with_boundary_id(const Elem *const elem, const boundary_id_type boundary_id) const
The definition of the bnd_node_iterator struct.
unsigned int n_elem_integers() const
std::vector< const ElemInfo * > _elem_info
Holds only those ElemInfo objects that have processor_id equal to this process's id, e.g.
void buildHRefinementAndCoarseningMaps(Assembly *assembly)
boundary_id_type pairedboundary
PeriodicBoundaryBase * boundary(boundary_id_type id)
bool usingGeneralAxisymmetricCoordAxes() const
Returns true if general axisymmetric coordinate axes are being used.
std::map< std::pair< int, libMesh::ElemType >, std::vector< std::vector< QpMap > > > _elem_type_to_refinement_map
Holds mappings for volume to volume and parent side to child side Map key:
const std::set< SubdomainID > & getBlockConnectedBlocks(const SubdomainID subdomain_id) const
Get the list of subdomains neighboring a given subdomain.
virtual const Node * queryNodePtr(const dof_id_type i) const
virtual std::unique_ptr< Partitioner > & partitioner()
std::unordered_map< std::pair< const Elem *, unsigned short int >, const Elem * > _higher_d_elem_side_to_lower_d_elem
Holds a map from a high-order element side to its corresponding lower-d element.
Helper object for holding qp mapping info.
unsigned int size() const
Return the number of active items in the MultiMooseEnum.
void mooseInfoRepeated(Args &&... args)
Emit an informational message with the given stringified, concatenated args.
bool _has_lower_d
Whether there are any lower-dimensional blocks that are manifolds of higher-dimensional block faces...
const std::vector< Real > & getGhostedBoundaryInflation() const
Return a writable reference to the _ghosted_boundaries_inflation vector.
std::unique_ptr< ConstElemPointerRange > _refined_elements
The elements that were just refined.
std::vector< std::vector< bool > > _id_identical_flag
Flags to indicate whether or not any two extra element integers are the same.
virtual dof_id_type maxElemId() const
static constexpr std::size_t dim
This is the dimension of all vector and tensor datastructures used in MOOSE.
const Parallel::Communicator & comm() const
virtual bnd_elem_iterator bndElemsBegin()
Return iterators to the beginning/end of the boundary elements list.
void setUniformRefineLevel(unsigned int, bool deletion=true)
Set uniform refinement level.
virtual unsigned int n_children() const=0
unsigned int p_level() const
void allgather_packed_range(Context *context, Iter range_begin, const Iter range_end, OutputIter out, std::size_t approx_buffer_size=1000000) const
MooseEnum _partitioner_name
The partitioner used on this mesh.
std::unique_ptr< libMesh::ConstElemRange > _active_local_elem_range
A range for use with threading.
std::map< dof_id_type, std::set< SubdomainID > > _block_node_list
list of nodes that belongs to a specified block (domain)
bool _node_to_active_semilocal_elem_map_built
void build_side_boundary_ids(std::vector< boundary_id_type > &b_ids) const
std::map< boundary_id_type, std::set< dof_id_type > > _bnd_node_ids
Map of sets of node IDs in each boundary.
virtual void init()
Initialize the Mesh object.
ConstElemPointerRange * refinedElementRange() const
Return a range that is suitable for threaded execution over elements that were just refined...
void boundary_ids(const Node *node, std::vector< boundary_id_type > &vec_to_fill) const
unsigned int getHigherDSide(const Elem *elem) const
Returns the local side ID of the interior parent aligned with the lower dimensional element...
std::unordered_map< std::pair< const Elem *, unsigned int >, FaceInfo * > _elem_side_to_face_info
Map from elem-side pair to FaceInfo.
void detectPairedSidesets()
This routine detects paired sidesets of a regular orthogonal mesh (.i.e.
const std::set< SubdomainID > & getNodeBlockIds(const Node &node) const
Return list of blocks to which the given node belongs.
virtual std::unique_ptr< Partitioner > clone() const=0
const Parallel::Communicator & _communicator
std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap > > _elem_type_to_p_coarsening_side_map
void setMeshBoundaryIDs(std::set< BoundaryID > boundary_IDs)
Sets the set of BoundaryIDs Is called by AddAllSideSetsByNormals.
std::map< boundary_id_type, std::vector< dof_id_type > > _node_set_nodes
list of nodes that belongs to a specified nodeset: indexing [nodeset_id] -> [array of node ids] ...
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.
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
std::set< SubdomainID > _lower_d_boundary_blocks
Mesh blocks for boundary lower-d elements in different types.
std::basic_ostream< charT, traits > * os
void build_active_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
void changeBoundaryId(const boundary_id_type old_id, const boundary_id_type new_id, bool delete_prev)
Change all the boundary IDs for a given side from old_id to new_id.
Base class for a system (of equations)
const BoundaryInfo & get_boundary_info() const
std::set< Elem * > _ghost_elems_from_ghost_boundaries
Set of elements ghosted by ghostGhostedBoundaries.
virtual void buildMesh()=0
Must be overridden by child classes.
void setPartitionerHelper(MeshBase *mesh=nullptr)
void deleteRemoteElements()
Delete remote elements.
bool isSplitMesh() const
Whether or not this is a split mesh operation.
unsigned int _to
The qp to map to.
BoundaryID _bnd_id
boundary id for the node
libMesh::ConstNodeRange * getLocalNodeRange()
virtual std::unique_ptr< MeshBase > clone() const=0
Real distance(const Point &p)
virtual const Node & nodeRef(const dof_id_type i) const
bool _allow_recovery
Whether or not this Mesh is allowed to read a recovery file.
virtual const std::string & name() const
Get the name of the class.
virtual Node * add_point(const Point &p, const dof_id_type id=DofObject::invalid_id, const processor_id_type proc_id=DofObject::invalid_processor_id)=0
std::vector< SubdomainID > getSubdomainIDs(const std::vector< SubdomainName > &subdomain_names) const
Get the associated subdomainIDs for the subdomain names that are passed in.
bool operator()(const BndNode *const &lhs, const BndNode *const &rhs)
void buildNodeListFromSideList()
Calls BoundaryInfo::build_node_list_from_side_list().
void mooseWarning(Args &&... args) const
Emits a warning prefixed with object name and type.
FEProblemBase & feProblem() const
const std::string & getSubdomainName(SubdomainID subdomain_id) const
Return the name of a block given an id.
void setPatchUpdateStrategy(Moose::PatchUpdateType patch_update_strategy)
Set the patch size update strategy.
void buildFiniteVolumeInfo() const
Builds the face and elem info vectors that store meta-data needed for looping over and doing calculat...
std::unordered_map< SubdomainID, std::set< BoundaryID > > _neighbor_subdomain_boundary_ids
Holds a map from neighbor subomdain ids to the boundary ids that are attached to it.
const std::pair< Point, RealVectorValue > & getGeneralAxisymmetricCoordAxis(SubdomainID subdomain_id) const
Gets the general axisymmetric coordinate axis for a block.
void reinit(const Elem *elem)
Reinitialize objects (JxW, q_points, ...) for an elements.
SubdomainID getSubdomainID(const SubdomainName &subdomain_name, const MeshBase &mesh)
Gets the subdomain ID associated with the given SubdomainName.
auto max(const L &left, const R &right)
const std::set< BoundaryID > & meshBoundaryIds() const
Returns a read-only reference to the set of boundary IDs currently present in the Mesh...
std::set< SubdomainID > _lower_d_interior_blocks
Mesh blocks for interior lower-d elements in different types.
virtual Elem * queryElemPtr(const dof_id_type i)
elem_info_iterator ownedElemInfoBegin()
Iterators to owned faceInfo objects.
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
void setIsCustomPartitionerRequested(bool cpr)
bool isParamValid(const std::string &name) const
Test if the supplied parameter is valid.
const std::set< boundary_id_type > & get_node_boundary_ids() const
unsigned int _max_h_level
Maximum h-refinement level of all elements.
virtual bnd_node_iterator bndNodesBegin()
Return iterators to the beginning/end of the boundary nodes list.
void mapPoints(const std::vector< Point > &from, const std::vector< Point > &to, std::vector< QpMap > &qp_map)
Find the closest points that map "from" to "to" and fill up "qp_map".
BoundaryID getBoundaryID(const BoundaryName &boundary_name, const MeshBase &mesh)
Gets the boundary ID associated with the given BoundaryName.
virtual Point get_corresponding_pos(const Point &pt) const=0
void errorIfDistributedMesh(std::string name) const
Generate a unified error message if the underlying libMesh mesh is a DistributedMesh.
const MeshBase * getMeshPtr() const
bool getDistributedMeshOnCommandLine() const
Returns true if the user specified –distributed-mesh (or –parallel-mesh, for backwards compatibilit...
This data structure is used to store geometric and variable related metadata about each cell face in ...
const std::vector< const FaceInfo * > & faceInfo() const
Accessor for local FaceInfo objects.
void updateCoordTransform()
Update the coordinate transformation object based on our coordinate system data.
static const int GRAIN_SIZE
bool _use_distributed_mesh
False by default.
virtual bool is_serial() const
void libmesh_ignore(const Args &...)
void build_node_list(std::vector< dof_id_type > &node_id_list, std::vector< boundary_id_type > &bc_id_list) const
static const subdomain_id_type invalid_subdomain_id
std::unique_ptr< std::map< BoundaryID, RealVectorValue > > _boundary_to_normal_map
The boundary to normal map - valid only when AddAllSideSetsByNormals is active.
const dof_id_type n_nodes
virtual void find_neighbors(const bool reset_remote_elements=false, const bool reset_current_list=true)=0
bool _built_from_other_mesh
Whether or not this mesh was built from another mesh.
bool _allow_remote_element_removal
Whether to allow removal of remote elements.
virtual bool skipNoncriticalPartitioning() const
SemiLocalNodeRange * getActiveSemiLocalNodeRange() const
std::unordered_set< dof_id_type > getBoundaryActiveNeighborElemIds(BoundaryID bid) const
Return all ids of neighbors of elements which have a side which is part of a sideset.
void setSubdomainName(SubdomainID subdomain_id, const SubdomainName &name)
This method sets the name for subdomain_id to name.
virtual void delete_elem(Elem *e)=0
void clearQuadratureNodes()
Clear out any existing quadrature nodes.
MeshBase & getMesh()
Accessor for the underlying libMesh Mesh object.
void min(const T &r, T &o, Request &req) const
const std::map< SubdomainID, Moose::CoordinateSystemType > & getCoordSystem() const
Get the map from subdomain ID to coordinate system type, e.g.
std::vector< BndNode * > _bnd_nodes
array of boundary nodes
virtual unsigned int n_nodes() const=0
Every object that can be built by the factory should be derived from this class.
virtual unsigned int dimension() const
Returns MeshBase::mesh_dimension(), (not MeshBase::spatial_dimension()!) of the underlying libMesh me...
unsigned int _from
The qp to map from.
std::pair< const Node *, BoundaryID > PeriodicNodeInfo
Helper type for building periodic node maps.
std::unique_ptr< MeshBase > buildMeshBaseObject(unsigned int dim=libMesh::invalid_uint)
Method to construct a libMesh::MeshBase object that is normally set and used by the MooseMesh object ...
unsigned int getAxisymmetricRadialCoord() const
Returns the desired radial direction for RZ coordinate transformation.
const Point & min() const
virtual Elem * add_elem(Elem *e)=0
const std::set< unsigned int > & getGhostedBoundaries() const
Return a writable reference to the set of ghosted boundary IDs.
bool _construct_node_list_from_side_list
Whether or not to allow generation of nodesets from sidesets.
boundary_id_type BoundaryID
void print_info(std::ostream &os=libMesh::out, const unsigned int verbosity=0, const bool global=true) const
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
unsigned int sideWithBoundaryID(const Elem *const elem, const BoundaryID boundary_id) const
Calls BoundaryInfo::side_with_boundary_id().
const std::vector< dof_id_type > & getNodeList(boundary_id_type nodeset_id) const
Return a writable reference to a vector of node IDs that belong to nodeset_id.
virtual const Node * nodePtr(const dof_id_type i) const
virtual const Node * query_node_ptr(const dof_id_type i) const=0
virtual libMesh::EquationSystems & es() override
std::vector< dof_id_type > _max_ids
Maximum integer ID for each extra element integer.
virtual dof_id_type max_elem_id() const=0
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
void family_tree(T elem, std::vector< T > &family, bool reset=true)
void update()
Calls buildNodeListFromSideList(), buildNodeList(), and buildBndElemList().
static const dof_id_type invalid_id
const std::string & type() const
Get the type of this class.
const std::pair< BoundaryID, BoundaryID > * getPairedBoundaryMapping(unsigned int component)
This function attempts to return the paired boundary ids for the given component. ...
const T & getParam(const std::string &name) const
Retrieve a parameter for the object.
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
std::set< BoundaryID > _mesh_nodeset_ids
virtual bool is_remote() const
std::unique_ptr< MooseAppCoordTransform > _coord_transform
A coordinate transformation object that describes how to transform this problem's coordinate system i...
std::set< SubdomainID > getBoundaryConnectedBlocks(const BoundaryID bid) const
Get the list of subdomains associated with the given boundary.
void checkCoordinateSystems()
Performs a sanity check for every element in the mesh.
std::vector< BoundaryID > getBoundaryIDs(const libMesh::MeshBase &mesh, const std::vector< BoundaryName > &boundary_name, bool generate_unknown, const std::set< BoundaryID > &mesh_boundary_ids)
Gets the boundary IDs with their names.
std::string & subdomain_name(subdomain_id_type id)
std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap > > _elem_type_to_p_refinement_side_map
const std::set< unsigned char > & elem_dimensions() const
std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap > > _elem_type_to_p_coarsening_map
const bool _is_split
Whether or not we are using a (pre-)split mesh (automatically DistributedMesh)
void setCoordSystem(const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)
Set the coordinate system for the provided blocks to coord_sys.
std::unique_ptr< ConstElemPointerRange > _coarsened_elements
The elements that were just coarsened.
void allow_find_neighbors(bool allow)
void set_mesh_dimension(unsigned char d)
std::set< dof_id_type > getAllElemIDs(unsigned int elem_id_index) const
Return all the unique element IDs for an extra element integer with its index.
std::set< BoundaryID > _mesh_boundary_ids
A set of boundary IDs currently present in the mesh.
const Node * addUniqueNode(const Point &p, Real tol=1e-6)
Add a new node to the mesh.
std::vector< BndNode > _extra_bnd_nodes
MooseApp & _app
The MOOSE application this is associated with.
void paramError(const std::string ¶m, Args... args) const
Emits an error prefixed with the file and line number of the given param (from the input file) along ...
bool _moose_mesh_prepared
True if prepare has been called on the mesh.
void buildRefinementMap(const Elem &elem, libMesh::QBase &qrule, libMesh::QBase &qrule_face, int parent_side, int child, int child_side)
Build the refinement map for a given element type.
The definition of the face_info_iterator struct.
unsigned int uniformRefineLevel() const
Returns the level of uniform refinement requested (zero if AMR is disabled).
std::vector< BndElement * > _bnd_elems
array of boundary elems
std::string stringify(const T &t)
conversion to string
bool _coord_system_set
Whether the coordinate system has been set.
std::vector< SubdomainName > getSubdomainNames(const std::vector< SubdomainID > &subdomain_ids) const
Get the associated subdomainNames for the subdomain ids that are passed in.
const std::vector< QpMap > & getPRefinementMap(const Elem &elem) const
Get the map describing for each volumetric quadrature point (qp) on the refined level which qp on the...
AuxiliarySystem & getAuxiliarySystem()
Real minPeriodicDistance(unsigned int nonlinear_var_num, Point p, Point q) const
This function returns the distance between two points on the mesh taking into account periodicity for...
bool hasSecondOrderElements()
check if the mesh has SECOND order elements
unsigned int getPatchSize() const
Getter for the patch_size parameter.
void buildRefinementAndCoarseningMaps(Assembly *assembly)
Create the refinement and coarsening maps necessary for projection of stateful material properties wh...
bool _parallel_type_overridden
const std::string & get_nodeset_name(boundary_id_type id) const
Interface for objects interacting with the PerfGraph.
MeshBase::element_iterator activeLocalElementsBegin()
Calls active_local_nodes_begin/end() on the underlying libMesh mesh object.
std::vector< Node * > _node_map
Vector of all the Nodes in the mesh for determining when to add a new point.
std::map< dof_id_type, std::map< unsigned int, std::map< dof_id_type, Node * > > > _elem_to_side_to_qp_to_quadrature_nodes
const std::vector< QpMap > & getPRefinementSideMap(const Elem &elem) const
Get the map describing for each side quadrature point (qp) on the refined level which qp on the previ...
std::unordered_map< dof_id_type, ElemInfo > _elem_to_elem_info
Map connecting elems with their corresponding ElemInfo, we use the element ID as the key...
libMesh::Node * _node
pointer to the node
Node * getQuadratureNode(const Elem *elem, const unsigned short int side, const unsigned int qp)
Get a specified quadrature node.
void printInfo(std::ostream &os=libMesh::out, const unsigned int verbosity=0) const
Calls print_info() on the underlying Mesh.
std::string & sideset_name(boundary_id_type id)
virtual dof_id_type nNodes() const
Calls n_nodes/elem() on the underlying libMesh mesh object.
std::pair< T, U > ResultItem
static MooseEnum partitioning()
returns MooseMesh partitioning options so other classes can use it
const std::set< boundary_id_type > & get_boundary_ids() const
const std::vector< std::vector< dof_id_type > > & dofIndices() const
virtual Node * add_node(Node *n)=0
virtual const Elem * elem_ptr(const dof_id_type i) const=0
void buildCoarseningMap(const Elem &elem, libMesh::QBase &qrule, libMesh::QBase &qrule_face, int input_side)
Build the coarsening map for a given element type.
virtual unsigned int n_sides() const=0
const std::vector< const Elem * > & coarsenedElementChildren(const Elem *elem) const
Get the newly removed children element ids for an element that was just coarsened.
std::unordered_map< dof_id_type, std::set< dof_id_type > > getElemIDMapping(const std::string &from_id_name, const std::string &to_id_name) const
std::map< std::pair< int, libMesh::ElemType >, std::vector< std::pair< unsigned int, QpMap > > > _elem_type_to_coarsening_map
Holds mappings for volume to volume and parent side to child side Map key:
void setBoundaryName(BoundaryID boundary_id, BoundaryName name)
This method sets the boundary name of the boundary based on the id parameter.
const Elem * neighbor_ptr(unsigned int i) const
void remove_side(const Elem *elem, const unsigned short int side)
bool isParamSetByUser(const std::string &nm) const
Test if the supplied parameter is set by a user, as opposed to not set or set to default.
Moose::PatchUpdateType _patch_update_strategy
The patch update strategy.
infix_ostream_iterator< T, charT, traits > & operator=(T const &item)
Physical unit management class with runtime unit string parsing, unit checking, unit conversion...
void addPeriodicVariable(unsigned int var_num, BoundaryID primary, BoundaryID secondary)
For "regular orthogonal" meshes, determine if variable var_num is periodic with respect to the primar...
bool absolute_fuzzy_equals(const T &var1, const T2 &var2, const Real tol=TOLERANCE *TOLERANCE)
unsigned int level() const
void setCurrentSubdomainID(SubdomainID i)
set the current subdomain ID
std::set< BoundaryID > _mesh_sideset_ids
void setGeneralAxisymmetricCoordAxes(const std::vector< SubdomainName > &blocks, const std::vector< std::pair< Point, RealVectorValue >> &axes)
Sets the general coordinate axes for axisymmetric blocks.
void setBoundaryToNormalMap(std::unique_ptr< std::map< BoundaryID, RealVectorValue >> boundary_map)
Sets the mapping between BoundaryID and normal vector Is called by AddAllSideSetsByNormals.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
bool _partitioner_overridden
bool detectOrthogonalDimRanges(Real tol=1e-6)
This routine determines whether the Mesh is a regular orthogonal mesh (i.e.
virtual const Elem * query_elem_ptr(const dof_id_type i) const=0
void updateActiveSemiLocalNodeRange(std::set< dof_id_type > &ghosted_elems)
Clears the "semi-local" node list and rebuilds it.
subdomain_id_type subdomain_id() const
std::map< const Elem *, std::vector< const Elem * > > _coarsened_element_children
Map of Parent elements to children elements for elements that were just coarsened.
std::set< dof_id_type > getElemIDsOnBlocks(unsigned int elem_id_index, const std::set< SubdomainID > &blks) const
Return all the unique element IDs for an extra element integer with its index on a set of subdomains...
unsigned int getBlocksMaxDimension(const std::vector< SubdomainName > &blocks) const
Returns the maximum element dimension on the given blocks.
std::unique_ptr< libMesh::MeshBase > _mesh
Pointer to underlying libMesh mesh object.
void max(const T &r, T &o, Request &req) const
libMesh::NodeRange * getActiveNodeRange()
virtual unsigned short dim() const=0
infix_ostream_iterator< T, charT, traits > & operator*()
const Node * node_ptr(const unsigned int i) const
void setGhostedBoundaryInflation(const std::vector< Real > &inflation)
This sets the inflation amount for the bounding box for each partition for use in ghosting boundaries...
The definition of the elem_info_iterator struct.
Real dimensionWidth(unsigned int component) const
Returns the width of the requested dimension.
PatchUpdateType
Type of patch update strategy for modeling node-face constraints or contact.
bool is_my_variable(unsigned int var_num) const
bool _skip_deletion_repartition_after_refine
Whether or not skip remote deletion and repartition after uniform refinements.
std::set< SubdomainID > getBoundaryConnectedSecondaryBlocks(const BoundaryID bid) const
Get the list of subdomains associated with the given boundary of its secondary side.
void add_side(const dof_id_type elem, const unsigned short int side, const boundary_id_type id)
bool _need_delete
Whether we need to delete remote elements after init'ing the EquationSystems.
const std::string & get_sideset_name(boundary_id_type id) const
std::map< std::pair< libMesh::ElemType, unsigned int >, std::vector< QpMap > > _elem_type_to_p_refinement_map
void setAxisymmetricCoordAxis(const MooseEnum &rz_coord_axis)
For axisymmetric simulations, set the symmetry coordinate axis.
std::set< BoundaryID > getSubdomainInterfaceBoundaryIds(const SubdomainID subdomain_id) const
Get the list of boundaries that contact the given subdomain.
std::vector< const Elem * > _refined_elements
The elements that were just refined.
IntRange< T > make_range(T beg, T end)
virtual const Node & node(const dof_id_type i) const
Various accessors (pointers/references) for Node "i".
infix_ostream_iterator< T, charT, traits > & operator++()
libMesh::BoundingBox getInflatedProcessorBoundingBox(Real inflation_multiplier=0.01) const
Get a (slightly inflated) processor bounding box.
std::map< unsigned int, std::vector< bool > > _periodic_dim
A map of vectors indicating which dimensions are periodic in a regular orthogonal mesh for the specif...
unsigned int mesh_dimension() const
void setMeshBase(std::unique_ptr< MeshBase > mesh_base)
Method to set the mesh_base object.
void mooseError(Args &&... args) const
Emits an error prefixed with object name and type.
std::set< SubdomainID > getInterfaceConnectedBlocks(const BoundaryID bid) const
Get the list of subdomains contacting the given boundary.
const InputParameters & _pars
Parameters of this object, references the InputParameters stored in the InputParametersWarehouse.
SolverSystem & getSolverSystem(unsigned int sys_num)
Get non-constant reference to a solver system.
std::vector< Real > _ghosted_boundaries_inflation
virtual SimpleRange< element_iterator > active_subdomain_set_elements_ptr_range(std::set< subdomain_id_type > ss)=0
std::vector< std::unordered_map< SubdomainID, std::set< dof_id_type > > > _block_id_mapping
Unique element integer IDs for each subdomain and each extra element integers.
IntRange< unsigned short > node_index_range() const
void findAdaptivityQpMaps(const Elem *template_elem, libMesh::QBase &qrule, libMesh::QBase &qrule_face, std::vector< std::vector< QpMap >> &refinement_map, std::vector< std::pair< unsigned int, QpMap >> &coarsen_map, int parent_side, int child, int child_side)
Given an elem type, get maps that tell us what qp's are closest to each other between a parent and it...
unsigned int _patch_size
The number of nodes to consider in the NearestNode neighborhood.
elem_info_iterator ownedElemInfoEnd()
void buildPeriodicNodeSets(std::map< BoundaryID, std::set< dof_id_type >> &periodic_node_sets, unsigned int var_number, libMesh::PeriodicBoundaries *pbs) const
This routine builds a datastructure of node ids organized by periodic boundary ids.
virtual std::unique_ptr< libMesh::PointLocatorBase > getPointLocator() const
Proxy function to get a (sub)PointLocator from either the underlying libMesh mesh (default)...
void addGhostedBoundary(BoundaryID boundary_id)
This will add the boundary ids to be ghosted to this processor.
virtual dof_id_type maxNodeId() const
Calls max_node/elem_id() on the underlying libMesh mesh object.
virtual Elem * elem(const dof_id_type i)
Various accessors (pointers/references) for Elem "i".
libMesh::StoredRange< MooseMesh::const_bnd_elem_iterator, const BndElement * > * getBoundaryElementRange()
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
void paramWarning(const std::string ¶m, Args... args) const
Emits a warning prefixed with the file and line number of the given param (from the input file) along...
face_info_iterator ownedFaceInfoEnd()
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type...
std::unordered_map< SubdomainID, std::pair< Point, RealVectorValue > > _subdomain_id_to_rz_coord_axis
Map of subdomain ID to general axisymmetric axis.
Class used for caching additional information for elements such as the volume and centroid...
MeshBase::node_iterator localNodesEnd()
const RealVectorValue & getNormalByBoundaryID(BoundaryID id) const
Returns the normal vector associated with a given BoundaryID.
std::set< SubdomainID > _mesh_subdomains
A set of subdomain IDs currently present in the mesh.
ConstElemPointerRange * coarsenedElementRange() const
Return a range that is suitable for threaded execution over elements that were just coarsened...
static InputParameters validParams()
const Moose::PatchUpdateType & getPatchUpdateStrategy() const
Get the current patch update strategy.
bool doingPRefinement() const
Query whether we have p-refinement.
std::vector< std::pair< BoundaryID, BoundaryID > > _paired_boundary
A vector holding the paired boundaries for a regular orthogonal mesh.
const Point & max() const
void ghostGhostedBoundaries()
Actually do the ghosting of boundaries that need to be ghosted to this processor. ...
std::set< unsigned int > _ghosted_boundaries
MeshBase::node_iterator localNodesBegin()
Calls local_nodes_begin/end() on the underlying libMesh mesh object.
unsigned int _rz_coord_axis
Storage for RZ axis selection.
void computeFiniteVolumeCoords() const
Compute the face coordinate value for all FaceInfo and ElemInfo objects.
void buildNodeList()
Calls BoundaryInfo::build_node_list()/build_side_list() and makes separate copies of Nodes/Elems in t...
virtual dof_id_type max_node_id() const=0
std::unordered_map< SubdomainID, SubdomainData > _sub_to_data
Holds a map from subdomain ids to associated data.
std::unique_ptr< libMesh::Partitioner > _custom_partitioner
The custom partitioner.
bool isBoundaryElem(dof_id_type elem_id) const
Returns true if the requested element is in the list of boundary elements, false otherwise.
virtual dof_id_type n_elem() const=0
virtual const Node * node_ptr(const dof_id_type i) const=0
std::map< const Elem *, std::vector< const Elem * > > _coarsened_element_children
Map of Parent elements to child elements for elements that were just coarsened.
processor_id_type processor_id() const
const std::vector< QpMap > & getPCoarseningMap(const Elem &elem) const
Get the map describing for each volumetric quadrature point (qp) on the coarse level which qp on the ...
bool isRecovering() const
Whether or not this is a "recover" calculation.
auto min(const L &left, const R &right)
virtual std::size_t numSolverSystems() const override
SearchParams SearchParameters
std::vector< const Elem * > _coarsened_elements
The elements that were just coarsened.
void buildPeriodicNodeMap(std::multimap< dof_id_type, dof_id_type > &periodic_node_map, unsigned int var_number, libMesh::PeriodicBoundaries *pbs) const
This routine builds a multimap of boundary ids to matching boundary ids across all periodic boundarie...
processor_id_type processor_id() const
std::string getRestartRecoverFileBase() const
The file_base for the recovery file.
virtual ElemType type() const=0
dof_id_type node_id(const unsigned int i) const
const Point & point(const unsigned int i) const
const std::unordered_map< boundary_id_type, std::unordered_set< dof_id_type > > & getBoundariesToActiveSemiLocalElemIds() const
Returns a map of boundaries to ids of elements on the boundary.
const MeshBase::element_iterator activeLocalElementsEnd()
bool relative_fuzzy_equals(const TypeVector< Real > &rhs, Real tol=TOLERANCE) const
std::unique_ptr< libMesh::ConstNodeRange > _local_node_range
libMesh::StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > * getBoundaryNodeRange()
void ErrorVector unsigned int
auto index_range(const T &sizable)
bool _regular_orthogonal_mesh
Boolean indicating whether this mesh was detected to be regular and orthogonal.
std::map< dof_id_type, std::vector< dof_id_type > > _node_to_active_semilocal_elem_map
A map of all of the current nodes to the active elements that they are connected to.
virtual dof_id_type n_nodes() const=0
bool prepare(const MeshBase *mesh_to_clone)
Calls prepare_for_use() if the underlying MeshBase object isn't prepared, then communicates various b...
const ElemInfo & elemInfo(const dof_id_type id) const
Accessor for the elemInfo object for a given element ID.
void setCustomPartitioner(libMesh::Partitioner *partitioner)
Setter for custom partitioner.
Real _distance
The distance between them.
SubdomainID subdomain_id() const
We return the subdomain ID of the corresponding libmesh element.
dof_id_type get_extra_integer(const unsigned int index) const
const Elem * child_ptr(unsigned int i) const
static MooseEnum elemTypes()
returns MooseMesh element type options
void meshChanged()
Declares that the MooseMesh has changed, invalidates cached data and rebuilds caches.
void buildPRefinementAndCoarseningMaps(Assembly *assembly)
BoundaryID getBoundaryID(const BoundaryName &boundary_name) const
Get the associated BoundaryID for the boundary name.
std::unique_ptr< libMesh::StoredRange< MooseMesh::const_bnd_node_iterator, const BndNode * > > _bnd_node_range
virtual dof_id_type nElem() const
const std::map< dof_id_type, std::vector< dof_id_type > > & nodeToElemMap()
If not already created, creates a map from every node to all elements to which they are connected...
libMesh::QBase *const & writeableQRuleFace()
Returns the reference to the current quadrature being used on a current face.
bool isBoundaryFullyExternalToSubdomains(BoundaryID bid, const std::set< SubdomainID > &blk_group) const
Returns whether a boundary (given by its id) is not crossing through a group of blocks, by which we mean that elements on both sides of the boundary are in those blocks.
std::unique_ptr< SemiLocalNodeRange > _active_semilocal_node_range
const std::set< SubdomainID > & meshSubdomains() const
Returns a read-only reference to the set of subdomains currently present in the Mesh.
SubdomainID getSubdomainID(const SubdomainName &subdomain_name) const
Get the associated subdomain ID for the subdomain name.
unsigned int _max_p_level
Maximum p-refinement level of all elements.
void setupFiniteVolumeMeshData() const
Sets up the additional data needed for finite volume computations.
void set_union(T &data, const unsigned int root_id) const
const RemoteElem * remote_elem
virtual unsigned int effectiveSpatialDimension() const
Returns the effective spatial dimension determined by the coordinates actually used by the mesh...