21 #include "libmesh/elem.h" 22 #include "libmesh/elem_range.h" 23 #include "libmesh/libmesh_logging.h" 24 #include "libmesh/mesh_base.h" 25 #include "libmesh/mesh_communication.h" 26 #include "libmesh/mesh_serializer.h" 27 #include "libmesh/mesh_tools.h" 28 #include "libmesh/node_range.h" 29 #include "libmesh/parallel.h" 30 #include "libmesh/parallel_algebra.h" 31 #include "libmesh/parallel_ghost_sync.h" 32 #include "libmesh/sphere.h" 33 #include "libmesh/threads.h" 34 #include "libmesh/enum_to_string.h" 35 #include "libmesh/enum_elem_type.h" 36 #include "libmesh/int_range.h" 37 #include "libmesh/utility.h" 38 #include "libmesh/boundary_info.h" 41 # include "libmesh/remote_elem.h" 48 #include <unordered_map> 49 #include <unordered_set> 79 for (
const auto & elem : range)
80 _weight += elem->n_nodes();
88 #if LIBMESH_USING_THREADS 89 void join (
const SumElemWeight & other)
90 { _weight += other.weight(); }
107 FindBBox () : _bbox()
116 for (
const auto & node : range)
119 _bbox.union_with(*node);
125 for (
const auto & elem : range)
128 _bbox.union_with(elem->loose_bounding_box());
132 Point & min() {
return _bbox.min(); }
134 Point & max() {
return _bbox.max(); }
138 #if LIBMESH_USING_THREADS 139 void join (
const FindBBox & other)
141 _bbox.union_with(other._bbox);
161 const unsigned int n_sys = d->
n_systems();
163 std::vector<unsigned int>
n_vars (n_sys, 0);
164 for (
unsigned int s = 0; s != n_sys; ++s)
169 const unsigned int tot_n_vars =
172 std::vector<unsigned int> n_comp (tot_n_vars, 0);
173 std::vector<dof_id_type> first_dof (tot_n_vars, 0);
175 for (
unsigned int s = 0, i=0; s != n_sys; ++s)
181 for (
unsigned int v = 0; v !=
n_vars[s]; ++v, ++i)
183 n_comp[i] = d->
n_comp(s,v);
195 const unsigned int * p_ui =
nullptr;
196 const std::vector<unsigned int> * p_vui =
nullptr;
197 const std::vector<dof_id_type> * p_vdid =
nullptr;
208 #ifdef LIBMESH_ENABLE_UNIQUE_ID 211 const std::unordered_set<unique_id_type> & unique_ids)
228 bool invalid = d && ((d->
unique_id() != tempmin) ||
236 if (!d && tempmin == tempmax)
239 #endif // LIBMESH_ENABLE_UNIQUE_ID 242 void find_nodal_neighbors_helper(
const dof_id_type global_id,
243 const std::vector<const Elem *> & node_to_elem_vec,
244 std::vector<const Node *> & neighbors)
249 std::set<const Node *> neighbor_set;
256 for (
const auto & elem : node_to_elem_vec)
262 unsigned local_node_number = elem->local_node(global_id);
267 const unsigned short n_edges = elem->n_edges();
272 switch (elem->type())
276 switch (local_node_number)
280 neighbor_set.insert(elem->node_ptr(1));
285 neighbor_set.insert(elem->node_ptr(0));
289 libmesh_error_msg(
"Invalid local node number: " << local_node_number <<
" found." << std::endl);
296 switch (local_node_number)
301 neighbor_set.insert(elem->node_ptr(2));
306 neighbor_set.insert(elem->node_ptr(0));
307 neighbor_set.insert(elem->node_ptr(1));
311 libmesh_error_msg(
"Invalid local node number: " << local_node_number <<
" found." << std::endl);
318 switch (local_node_number)
322 neighbor_set.insert(elem->node_ptr(2));
327 neighbor_set.insert(elem->node_ptr(3));
332 neighbor_set.insert(elem->node_ptr(0));
333 neighbor_set.insert(elem->node_ptr(3));
338 neighbor_set.insert(elem->node_ptr(1));
339 neighbor_set.insert(elem->node_ptr(2));
343 libmesh_error_msg(
"Invalid local node number: " << local_node_number <<
" found." << std::endl);
354 unsigned current_edge = 0;
356 const unsigned short n_nodes = elem->n_nodes();
358 while (current_edge < n_edges)
361 bool found_edge =
false;
362 for (; current_edge<n_edges; ++current_edge)
363 if (elem->is_node_on_edge(local_node_number, current_edge))
372 const Node * node_to_save =
nullptr;
375 for (
unsigned other_node_this_edge = 0; other_node_this_edge !=
n_nodes; other_node_this_edge++)
376 if ( (elem->is_node_on_edge(other_node_this_edge, current_edge)) &&
377 (elem->node_id(other_node_this_edge) != global_id))
380 node_to_save = elem->node_ptr(other_node_this_edge);
387 neighbor_set.insert(node_to_save);
399 neighbors.assign(neighbor_set.begin(), neighbor_set.end());
423 return weight + unpartitioned_weight;
429 mesh.elements_end()),
442 mesh.pid_elements_end(pid)),
450 std::vector<std::vector<dof_id_type>> & nodes_to_elem_map)
455 libmesh_deprecated();
459 for (
const auto & elem :
mesh.element_ptr_range())
460 for (
auto & node : elem->node_ref_range())
462 libmesh_assert_less (node.id(), nodes_to_elem_map.size());
463 libmesh_assert_less (elem->id(),
mesh.
n_elem());
465 nodes_to_elem_map[node.id()].push_back(elem->id());
472 std::vector<std::vector<const Elem *>> & nodes_to_elem_map)
477 libmesh_deprecated();
481 for (
const auto & elem :
mesh.element_ptr_range())
482 for (
auto & node : elem->node_ref_range())
484 libmesh_assert_less (node.id(), nodes_to_elem_map.size());
486 nodes_to_elem_map[node.id()].push_back(elem);
493 std::unordered_map<
dof_id_type, std::vector<dof_id_type>> & nodes_to_elem_map)
495 nodes_to_elem_map.clear();
497 for (
const auto & elem :
mesh.element_ptr_range())
498 for (
auto & node : elem->node_ref_range())
499 nodes_to_elem_map[node.id()].push_back(elem->id());
505 std::unordered_map<
dof_id_type, std::vector<const Elem *>> & nodes_to_elem_map)
507 nodes_to_elem_map.clear();
509 for (
const auto & elem :
mesh.element_ptr_range())
510 for (
auto & node : elem->node_ref_range())
511 nodes_to_elem_map[node.id()].push_back(elem);
516 std::unordered_set<dof_id_type>
519 std::unordered_set<dof_id_type> boundary_nodes;
523 for (
const auto & elem :
mesh.active_element_ptr_range())
524 for (
auto s : elem->side_index_range())
525 if (elem->neighbor_ptr(s) ==
nullptr)
527 auto nodes_on_side = elem->nodes_on_side(s);
529 for (
auto & local_id : nodes_on_side)
530 boundary_nodes.insert(elem->node_ptr(local_id)->id());
533 return boundary_nodes;
536 std::unordered_set<dof_id_type>
539 std::unordered_set<dof_id_type> block_boundary_nodes;
543 for (
const auto & elem :
mesh.active_element_ptr_range())
544 for (
auto s : elem->side_index_range())
545 if (elem->neighbor_ptr(s) && (elem->neighbor_ptr(s)->subdomain_id() != elem->subdomain_id()))
547 auto nodes_on_side = elem->nodes_on_side(s);
549 for (
auto & local_id : nodes_on_side)
550 block_boundary_nodes.insert(elem->node_ptr(local_id)->id());
553 return block_boundary_nodes;
578 return find_bbox.bbox();
598 mesh.local_nodes_end()),
605 return find_bbox.bbox();
615 const Real diag = (bbox.second - bbox.first).
norm();
616 const Point cent = (bbox.second + bbox.first)/2;
618 return Sphere (cent, .5*diag);
629 mesh.local_elements_end()),
632 return find_bbox.bbox();
650 mesh.pid_elements_end(pid)),
657 return find_bbox.bbox();
669 const Real diag = (bbox.second - bbox.first).
norm();
670 const Point cent = (bbox.second + bbox.first)/2;
672 return Sphere (cent, .5*diag);
689 mesh.active_local_subdomain_elements_end(sid)),
696 return find_bbox.bbox();
708 const Real diag = (bbox.second - bbox.first).
norm();
709 const Point cent = (bbox.second + bbox.first)/2;
711 return Sphere (cent, .5*diag);
717 std::vector<ElemType> & et)
721 for (
const auto & elem :
mesh.element_ptr_range())
722 if (!std::count(et.begin(), et.end(), elem->type()))
723 et.push_back(elem->type());
732 mesh.type_elements_end (type)));
741 mesh.active_type_elements_end (type)));
746 const unsigned int level)
751 for (
const auto & elem :
as_range(
mesh.type_elements_begin(type),
752 mesh.type_elements_end(type)))
753 if ((elem->level() == level) && !elem->subactive())
764 for (
auto & elem :
mesh.active_local_element_ptr_range())
765 nl = std::max(elem->level() + 1, nl);
778 for (
const auto & elem :
as_range(
mesh.unpartitioned_elements_begin(),
779 mesh.unpartitioned_elements_end()))
781 nl = std::max(elem->level() + 1, nl);
793 for (
const auto & elem :
as_range(
mesh.local_elements_begin(),
794 mesh.local_elements_end()))
795 nl = std::max(elem->level() + 1, nl);
808 for (
const auto & elem :
as_range(
mesh.unpartitioned_elements_begin(),
809 mesh.unpartitioned_elements_end()))
810 nl = std::max(elem->level() + 1, nl);
819 libmesh_assert_equal_to(nl, paranoid_nl);
831 for (
const auto & elem :
mesh.element_ptr_range())
832 nl = std::max(elem->level() + 1, nl);
843 LOG_SCOPE(
"n_connected_components()",
"MeshTools");
848 libmesh_not_implemented();
861 std::vector<std::unordered_set<const Node *>> components;
867 auto find_component = [&components](
const Node * n) {
868 std::unordered_set<const Node *> * component =
nullptr;
870 for (
auto & c: components)
871 if (c.find(n) != c.end())
880 auto add_to_component =
882 (std::unordered_set<const Node *> & component,
const Node * n) {
884 auto current_component = find_component(n);
886 if (&component == current_component)
890 else if (!current_component)
897 component.merge(*current_component);
904 for (
const auto & elem :
mesh.element_ptr_range())
906 const Node * first_node = elem->node_ptr(0);
908 auto component = find_component(first_node);
913 for (
auto & c: components)
918 component = &components.emplace_back();
920 for (
const Node & n : elem->node_ref_range())
922 add_to_component(*component, &n);
924 auto it = constraint_rows.find(&n);
925 if (it == constraint_rows.end())
928 for (
const auto & [pr, val] : it->second)
932 if (std::abs(val) < constraint_tol)
935 const Elem * spline_elem = pr.first;
938 const Node * spline_node =
941 add_to_component(*component, spline_node);
946 for (
auto & component : components)
947 if (!component.empty())
959 std::set<dof_id_type> & not_subactive_node_ids)
961 for (
const auto & elem :
mesh.element_ptr_range())
962 if (!elem->subactive())
963 for (
auto & n : elem->node_ref_range())
964 not_subactive_node_ids.insert(n.id());
996 for (
const auto & elem :
as_range(
mesh.local_elements_begin(),
997 mesh.local_elements_end()))
998 if (elem->dim() ==
dim)
999 vol += elem->volume();
1003 for (
const auto & elem :
as_range(
mesh.unpartitioned_elements_begin(),
1004 mesh.unpartitioned_elements_end()))
1005 if (elem->dim() ==
dim)
1006 vol += elem->volume();
1016 libmesh_parallel_only(
mesh.
comm());
1018 unsigned int max_p_level = 0;
1021 for (
const auto & elem :
as_range(
mesh.local_elements_begin(),
1022 mesh.local_elements_end()))
1023 max_p_level = std::max(elem->p_level(), max_p_level);
1026 for (
const auto & elem :
as_range(
mesh.unpartitioned_elements_begin(),
1027 mesh.unpartitioned_elements_end()))
1028 max_p_level = std::max(elem->p_level(), max_p_level);
1031 return max_p_level + 1;
1038 const std::vector<std::vector<const Elem *>> & nodes_to_elem_map,
1039 std::vector<const Node *> & neighbors)
1041 find_nodal_neighbors_helper(node.
id(), nodes_to_elem_map[node.
id()],
1049 const std::unordered_map<
dof_id_type, std::vector<const Elem *>> & nodes_to_elem_map,
1050 std::vector<const Node *> & neighbors)
1052 const std::vector<const Elem *> node_to_elem_vec =
1053 libmesh_map_find(nodes_to_elem_map, node.
id());
1054 find_nodal_neighbors_helper(node.
id(), node_to_elem_vec, neighbors);
1060 std::map<
dof_id_type, std::vector<dof_id_type>> & hanging_nodes)
1063 for (
auto & elem :
mesh.active_local_element_ptr_range())
1064 if (elem->type() ==
QUAD4)
1065 for (
auto s : elem->side_index_range())
1072 if (neigh !=
nullptr)
1075 if (neigh->
level() < elem->level())
1077 const Elem * ancestor = elem;
1079 ancestor = ancestor->
parent();
1081 libmesh_assert_less (s_neigh, neigh->
n_neighbors());
1084 unsigned int local_node1=0;
1085 unsigned int local_node2=0;
1087 bool found_in_neighbor =
false;
1090 while (!elem->is_node_on_side(local_node1++,s)) { }
1094 local_node2=local_node1+1;
1097 while (!elem->is_node_on_side(local_node2++,s)) { }
1110 for (
unsigned int n=0;n<neigh->
n_sides();n++)
1111 if (neigh->
node_id(n) == node1)
1112 found_in_neighbor=
true;
1116 if (!found_in_neighbor)
1128 local_node2=local_node1+1;
1135 if (hanging_nodes[hanging_node].size()<2)
1137 hanging_nodes[hanging_node].push_back(neigh->
node_id(local_node1));
1138 hanging_nodes[hanging_node].push_back(neigh->
node_id(local_node2));
1149 std::vector<Elem *> nodeelem_to_delete;
1151 for (
auto & elem :
mesh.element_ptr_range())
1154 nodeelem_to_delete.push_back(elem);
1161 for (
auto & node_row : constraint_rows)
1162 for (
auto pr : node_row.second)
1164 const Elem * elem = pr.first.first;
1170 constraint_rows.clear();
1172 for (
Elem * elem : nodeelem_to_delete)
1174 Node * node = elem->node_ptr(0);
1184 LOG_SCOPE(
"libmesh_assert_valid_is_prepared()",
"MeshTools");
1189 std::unique_ptr<MeshBase> mesh_clone =
mesh.
clone();
1193 bool old_allow_renumbering = mesh_clone->allow_renumbering();
1194 mesh_clone->allow_renumbering(
false);
1195 bool old_allow_remote_element_removal =
1196 mesh_clone->allow_remote_element_removal();
1197 bool old_skip_partitioning = mesh_clone->skip_partitioning();
1198 mesh_clone->skip_partitioning(
true);
1199 mesh_clone->allow_remote_element_removal(
false);
1200 mesh_clone->prepare_for_use();
1201 mesh_clone->allow_renumbering(old_allow_renumbering);
1202 mesh_clone->allow_remote_element_removal(old_allow_remote_element_removal);
1203 mesh_clone->skip_partitioning(old_skip_partitioning);
1205 return (
mesh == *mesh_clone);
1214 LOG_SCOPE(
"libmesh_assert_equal_n_systems()",
"MeshTools");
1218 for (
const auto & elem :
mesh.element_ptr_range())
1221 n_sys = elem->n_systems();
1223 libmesh_assert_equal_to (elem->n_systems(), n_sys);
1226 for (
const auto & node :
mesh.node_ptr_range())
1229 n_sys = node->n_systems();
1231 libmesh_assert_equal_to (node->n_systems(), n_sys);
1237 #ifdef LIBMESH_ENABLE_AMR 1240 LOG_SCOPE(
"libmesh_assert_old_dof_objects()",
"MeshTools");
1242 for (
const auto & elem :
mesh.element_ptr_range())
1248 if (elem->has_dofs())
1251 for (
auto & node : elem->node_ref_range())
1252 if (node.has_dofs())
1258 #endif // LIBMESH_ENABLE_AMR 1264 LOG_SCOPE(
"libmesh_assert_valid_node_pointers()",
"MeshTools");
1269 for (
const Elem * elem :
mesh.element_ptr_range())
1274 elem->libmesh_assert_valid_node_pointers();
1275 for (
auto n : elem->neighbor_ptr_range())
1277 n->libmesh_assert_valid_node_pointers();
1279 libmesh_assert_not_equal_to (elem->parent(),
remote_elem);
1280 elem = elem->parent();
1289 LOG_SCOPE(
"libmesh_assert_valid_remote_elems()",
"MeshTools");
1291 for (
const auto & elem :
as_range(
mesh.local_elements_begin(),
1292 mesh.local_elements_end()))
1299 for (
auto n : elem->neighbor_ptr_range())
1302 #ifdef LIBMESH_ENABLE_AMR 1305 libmesh_assert_not_equal_to (parent,
remote_elem);
1309 if (elem->active() && elem->has_children())
1310 for (
auto & child : elem->child_ref_range())
1311 libmesh_assert_not_equal_to (&child,
remote_elem);
1320 LOG_SCOPE(
"libmesh_assert_valid_elem_ids()",
"MeshTools");
1325 for (
const auto & elem :
mesh.active_element_ptr_range())
1331 libmesh_assert_greater_equal (elemid, lastelemid);
1332 libmesh_assert_greater_equal (elemprocid, lastprocid);
1334 lastelemid = elemid;
1335 lastprocid = elemprocid;
1343 LOG_SCOPE(
"libmesh_assert_valid_amr_elem_ids()",
"MeshTools");
1345 for (
const auto & elem :
mesh.element_ptr_range())
1353 libmesh_assert_greater_equal (elem->id(), parent->
id());
1354 libmesh_assert_greater_equal (elem->processor_id(), parent->
processor_id());
1363 LOG_SCOPE(
"libmesh_assert_valid_amr_interior_parents()",
"MeshTools");
1365 for (
const auto & elem :
mesh.element_ptr_range())
1371 if (elem->dim() >= LIBMESH_DIM)
1383 if (ip->
level() == elem->level())
1384 libmesh_assert_equal_to (ip->
parent(),
1388 libmesh_assert_less (ip->
level(), elem->level());
1399 LOG_SCOPE(
"libmesh_assert_contiguous_dof_ids()",
"MeshTools");
1404 libmesh_parallel_only(
mesh.
comm());
1406 dof_id_type min_dof_id = std::numeric_limits<dof_id_type>::max(),
1407 max_dof_id = std::numeric_limits<dof_id_type>::min();
1410 for (
const auto * node :
mesh.local_node_ptr_range())
1412 for (
auto v :
make_range(node->n_vars(sysnum)))
1413 for (
auto c :
make_range(node->n_comp(sysnum, v)))
1416 min_dof_id = std::min (min_dof_id,
id);
1417 max_dof_id = std::max (max_dof_id,
id);
1422 for (
const auto * node :
mesh.node_ptr_range())
1426 for (
auto v :
make_range(node->n_vars(sysnum)))
1427 for (
auto c :
make_range(node->n_comp(sysnum, v)))
1441 LOG_SCOPE(
"libmesh_assert_topology_consistent_procids()",
"MeshTools");
1448 #ifdef LIBMESH_ENABLE_AMR 1452 for (
const auto & elem :
mesh.element_ptr_range())
1456 if (!elem->active() && !elem->subactive())
1465 bool matching_child_id =
false;
1473 matching_child_id =
true;
1485 LOG_SCOPE(
"libmesh_assert_topology_consistent_procids()",
"MeshTools");
1490 libmesh_parallel_only(
mesh.
comm());
1501 for (
const auto & node :
mesh.node_ptr_range())
1502 parallel_max_node_id = std::max<dof_id_type>(parallel_max_node_id,
1507 std::vector<bool> node_touched_by_me(parallel_max_node_id,
false);
1509 for (
const auto & elem :
as_range(
mesh.local_elements_begin(),
1510 mesh.local_elements_end()))
1514 for (
auto & node : elem->node_ref_range())
1517 node_touched_by_me[nodeid] =
true;
1520 std::vector<bool> node_touched_by_anyone(node_touched_by_me);
1523 for (
const auto & node :
mesh.local_node_ptr_range())
1528 node_touched_by_me[nodeid]);
1536 for (
const auto & elem :
mesh.active_element_ptr_range())
1537 for (
auto & node : elem->node_ref_range())
1538 libmesh_assert_equal_to
1539 (node.processor_id(),
1540 node.choose_processor_id(node.processor_id(),
1541 elem->processor_id()));
1546 #ifdef LIBMESH_ENABLE_AMR 1549 LOG_SCOPE(
"libmesh_assert_valid_refinement_tree()",
"MeshTools");
1551 for (
const auto & elem :
mesh.element_ptr_range())
1554 if (elem->has_children())
1555 for (
auto & child : elem->child_ref_range())
1557 libmesh_assert_equal_to (child.parent(), elem);
1563 else if (elem->ancestor())
1571 libmesh_assert_greater(elem->p_level(), 0);
1578 #endif // LIBMESH_ENABLE_AMR 1587 const Elem * bad_elem)
1589 for (
const auto & elem :
mesh.element_ptr_range())
1592 libmesh_assert_not_equal_to (elem->parent(), bad_elem);
1593 for (
auto n : elem->neighbor_ptr_range())
1594 libmesh_assert_not_equal_to (n, bad_elem);
1596 #ifdef LIBMESH_ENABLE_AMR 1597 if (elem->has_children())
1598 for (
auto & child : elem->child_ref_range())
1599 libmesh_assert_not_equal_to (&child, bad_elem);
1607 LOG_SCOPE(
"libmesh_assert_equal_points()",
"MeshTools");
1623 LOG_SCOPE(
"libmesh_assert_equal_connectivity()",
"MeshTools");
1632 std::vector<dof_id_type> nodes;
1635 nodes.push_back(e->
node_id(n));
1644 LOG_SCOPE(
"libmesh_assert_connected_nodes()",
"MeshTools");
1646 std::set<const Node *> used_nodes;
1648 for (
const auto & elem :
mesh.element_ptr_range())
1652 for (
auto & n : elem->node_ref_range())
1653 used_nodes.insert(&n);
1656 for (
const auto & node :
mesh.node_ptr_range())
1667 libmesh_parallel_only(
mesh.
comm());
1671 bool have_constraint_rows = !constraint_rows.empty();
1673 if (!have_constraint_rows)
1676 for (
auto & row : constraint_rows)
1678 const Node * node = row.first;
1681 for (
auto & pr : row.second)
1683 const Elem * spline_elem = pr.first.first;
1695 bool have_constraint = constraint_rows.count(node);
1697 const std::size_t my_n_constraints = have_constraint ?
1698 libmesh_map_find(constraint_rows, node).size() : std::size_t(-1);
1699 const std::size_t * n_constraints = node ?
1700 &my_n_constraints :
nullptr;
1710 LOG_SCOPE(
"libmesh_assert_valid_boundary_ids()",
"MeshTools");
1715 libmesh_parallel_only(
mesh.
comm());
1725 const unsigned int my_n_nodes = elem ? elem->
n_nodes() : 0;
1726 const unsigned int my_n_edges = elem ? elem->
n_edges() : 0;
1727 const unsigned int my_n_sides = elem ? elem->
n_sides() : 0;
1730 n_edges = my_n_edges,
1731 n_sides = my_n_sides;
1739 libmesh_assert_equal_to(my_n_nodes,
n_nodes);
1740 libmesh_assert_equal_to(my_n_edges, n_edges);
1741 libmesh_assert_equal_to(my_n_sides, n_sides);
1747 std::vector<boundary_id_type> all_bcids;
1749 for (
unsigned int n=0; n !=
n_nodes; ++n)
1751 std::vector<boundary_id_type> bcids;
1754 boundary_info.boundary_ids(elem->
node_ptr(n), bcids);
1757 std::sort(bcids.begin(), bcids.end());
1761 all_bcids.insert(all_bcids.end(), bcids.begin(),
1767 for (
unsigned short e=0; e != n_edges; ++e)
1769 std::vector<boundary_id_type> bcids;
1773 boundary_info.edge_boundary_ids(elem, e, bcids);
1776 std::sort(bcids.begin(), bcids.end());
1781 all_bcids.insert(all_bcids.end(), bcids.begin(),
1788 boundary_info.raw_edge_boundary_ids(elem, e, bcids);
1791 std::sort(bcids.begin(), bcids.end());
1793 all_bcids.insert(all_bcids.end(), bcids.begin(),
1802 for (
unsigned short s=0; s != n_sides; ++s)
1804 std::vector<boundary_id_type> bcids;
1808 boundary_info.boundary_ids(elem, s, bcids);
1811 std::sort(bcids.begin(), bcids.end());
1813 all_bcids.insert(all_bcids.end(), bcids.begin(),
1823 boundary_info.raw_boundary_ids(elem, s, bcids);
1826 std::sort(bcids.begin(), bcids.end());
1828 all_bcids.insert(all_bcids.end(), bcids.begin(),
1837 for (
unsigned short sf=0; sf != 2; ++sf)
1839 std::vector<boundary_id_type> bcids;
1843 boundary_info.shellface_boundary_ids(elem, sf, bcids);
1846 std::sort(bcids.begin(), bcids.end());
1848 all_bcids.insert(all_bcids.end(), bcids.begin(),
1858 boundary_info.raw_shellface_boundary_ids(elem, sf, bcids);
1861 std::sort(bcids.begin(), bcids.end());
1863 all_bcids.insert(all_bcids.end(), bcids.begin(),
1873 (elem ? &all_bcids :
nullptr));
1880 LOG_SCOPE(
"libmesh_assert_valid_dof_ids()",
"MeshTools");
1885 libmesh_parallel_only(
mesh.
comm());
1891 assert_semiverify_dofobj(
mesh.
comm(),
1899 assert_semiverify_dofobj(
mesh.
comm(),
1905 #ifdef LIBMESH_ENABLE_UNIQUE_ID 1908 LOG_SCOPE(
"libmesh_assert_valid_unique_ids()",
"MeshTools");
1910 libmesh_parallel_only(
mesh.
comm());
1914 std::unordered_set<unique_id_type> semilocal_unique_ids;
1916 for (
auto const & elem :
mesh.active_element_ptr_range())
1919 semilocal_unique_ids.insert(elem->unique_id());
1922 for (
auto const & node :
mesh.node_ptr_range())
1925 semilocal_unique_ids.insert(node->unique_id());
1937 assert_dofobj_unique_id(
mesh.
comm(), elem, semilocal_unique_ids);
1949 assert_dofobj_unique_id(
mesh.
comm(), node, semilocal_unique_ids);
1956 libmesh_parallel_only(
mesh.
comm());
1961 for (
dof_id_type i=0; i != parallel_max_elem_id; ++i)
1973 for (
dof_id_type i=0; i != parallel_max_node_id; ++i)
1986 libmesh_parallel_only(
mesh.
comm());
1992 for (
dof_id_type i=0; i != parallel_max_elem_id; ++i)
1996 const unsigned int my_n_nodes = elem ? elem->
n_nodes() : 0;
1997 unsigned int n_nodes = my_n_nodes;
2003 for (
unsigned int n=0; n !=
n_nodes; ++n)
2005 const Node * node = elem ? elem->
node_ptr(n) :
nullptr;
2019 LOG_SCOPE(
"libmesh_assert_parallel_consistent_procids()",
"MeshTools");
2024 libmesh_parallel_only(
mesh.
comm());
2031 for (
const auto & elem :
mesh.element_ptr_range())
2032 parallel_max_elem_id = std::max<dof_id_type>(parallel_max_elem_id,
2038 for (
dof_id_type i=0; i != parallel_max_elem_id; ++i)
2044 std::numeric_limits<processor_id_type>::max();
2049 std::numeric_limits<processor_id_type>::min();
2054 libmesh_assert_equal_to (min_id, elem->
processor_id());
2055 libmesh_assert_equal_to (max_id, elem->
processor_id());
2067 LOG_SCOPE(
"libmesh_assert_parallel_consistent_new_node_procids()",
"MeshTools");
2072 libmesh_parallel_only(
mesh.
comm());
2080 std::vector<bool> elem_touched_by_anyone(parallel_max_elem_id,
false);
2082 for (
dof_id_type i=0; i != parallel_max_elem_id; ++i)
2086 const unsigned int my_n_nodes = elem ? elem->
n_nodes() : 0;
2087 unsigned int n_nodes = my_n_nodes;
2093 for (
unsigned int n=0; n !=
n_nodes; ++n)
2095 const Node * node = elem ? elem->
node_ptr(n) :
nullptr;
2105 LOG_SCOPE(
"libmesh_assert_parallel_consistent_procids()",
"MeshTools");
2110 libmesh_parallel_only(
mesh.
comm());
2121 for (
const auto & node :
mesh.node_ptr_range())
2122 parallel_max_node_id = std::max<dof_id_type>(parallel_max_node_id,
2126 std::vector<bool> node_touched_by_anyone(parallel_max_node_id,
false);
2128 for (
const auto & elem :
as_range(
mesh.local_elements_begin(),
2129 mesh.local_elements_end()))
2133 for (
auto & node : elem->node_ref_range())
2136 node_touched_by_anyone[nodeid] =
true;
2143 for (
dof_id_type i=0; i != parallel_max_node_id; ++i)
2145 if (!node_touched_by_anyone[i])
2157 #ifdef LIBMESH_ENABLE_AMR 2160 LOG_SCOPE(
"libmesh_assert_valid_refinement_flags()",
"MeshTools");
2162 libmesh_parallel_only(
mesh.
comm());
2169 std::vector<unsigned char> my_elem_h_state(pmax_elem_id, 255);
2170 std::vector<unsigned char> my_elem_p_state(pmax_elem_id, 255);
2172 for (
const auto & elem :
mesh.element_ptr_range())
2177 my_elem_h_state[elemid] =
2178 static_cast<unsigned char>(elem->refinement_flag());
2180 my_elem_p_state[elemid] =
2181 static_cast<unsigned char>(elem->p_refinement_flag());
2183 std::vector<unsigned char> min_elem_h_state(my_elem_h_state);
2186 std::vector<unsigned char> min_elem_p_state(my_elem_p_state);
2192 my_elem_h_state[i] == min_elem_h_state[i]);
2194 my_elem_p_state[i] == min_elem_p_state[i]);
2201 #endif // LIBMESH_ENABLE_AMR 2206 bool assert_valid_remote_elems)
2208 LOG_SCOPE(
"libmesh_assert_valid_neighbors()",
"MeshTools");
2210 for (
const auto & elem :
mesh.element_ptr_range())
2213 elem->libmesh_assert_valid_neighbors();
2219 libmesh_parallel_only(
mesh.
comm());
2228 const unsigned int my_n_neigh = elem ? elem->
n_neighbors() : 0;
2229 unsigned int n_neigh = my_n_neigh;
2232 libmesh_assert_equal_to (my_n_neigh, n_neigh);
2234 for (
unsigned int n = 0; n != n_neigh; ++n)
2243 p_my_neighbor = &my_neighbor;
2250 if (!assert_valid_remote_elems &&
2253 p_my_neighbor =
nullptr;
2266 typedef std::unordered_map<dof_id_type, processor_id_type> proc_id_map_type;
2270 typedef unsigned char datum;
2272 SyncNodeSet(std::unordered_set<const Node *> & _set,
2281 void gather_data (
const std::vector<dof_id_type> & ids,
2282 std::vector<datum> & data)
2285 data.resize(ids.size());
2300 bool act_on_data (
const std::vector<dof_id_type> & ids,
2301 const std::vector<datum> in_set)
2303 bool data_changed =
false;
2314 data_changed =
true;
2319 return data_changed;
2324 struct NodesNotInSet
2326 NodesNotInSet(
const std::unordered_set<const Node *> _set)
2329 bool operator() (
const Node * node)
const 2336 const std::unordered_set<const Node *>
node_set;
2340 struct SyncProcIdsFromMap
2344 SyncProcIdsFromMap(
const proc_id_map_type & _map,
2353 void gather_data (
const std::vector<dof_id_type> & ids,
2354 std::vector<datum> & data)
2357 data.resize(ids.size());
2367 data[i] = it->second;
2378 void act_on_data (
const std::vector<dof_id_type> & ids,
2379 const std::vector<datum> proc_ids)
2395 LOG_SCOPE(
"correct_node_proc_ids()",
"MeshTools");
2398 libmesh_parallel_only(
mesh.
comm());
2409 mesh.unpartitioned_elements_end()) == 0);
2428 std::unordered_set<const Node *> valid_nodes;
2435 if (!repartition_all_nodes)
2437 for (
const auto & elem :
mesh.active_element_ptr_range())
2438 for (
const auto & node : elem->node_ref_range())
2439 if (elem->processor_id() == node.processor_id())
2440 valid_nodes.insert(&node);
2442 SyncNodeSet syncv(valid_nodes,
mesh);
2451 for (
auto & elem :
mesh.active_element_ptr_range())
2455 for (
auto & node : elem->node_ref_range())
2462 it->second = node.choose_processor_id(it->second, pid);
2467 std::map<processor_id_type, std::vector<std::pair<dof_id_type, processor_id_type>>>
2470 for (
const auto & node :
mesh.node_ptr_range())
2471 if (
const auto it = std::as_const(
new_proc_ids).find(node->id());
2473 ids_to_push[node->processor_id()].emplace_back(node->id(), it->second);
2475 auto action_functor =
2478 const std::vector<std::pair<dof_id_type, processor_id_type>> & data)
2480 for (
const auto & [
id, pid] : data)
2493 Parallel::push_parallel_vector_data
2494 (
mesh.
comm(), ids_to_push, action_functor);
2500 std::unordered_set<Node *> ex_local_nodes;
2501 for (
auto & node :
mesh.local_node_ptr_range())
2504 ex_local_nodes.insert(node);
2507 if (repartition_all_nodes)
2512 NodesNotInSet nnis(valid_nodes);
2519 for (
const auto & node : ex_local_nodes)
2521 if (valid_nodes.count(node))
2525 const proc_id_map_type::iterator it =
new_proc_ids.find(
id);
2527 node->processor_id() = it->second;
2534 libmesh_assert_valid_procids<Node>(
mesh);
ElemType
Defines an enum for geometric element types.
dof_id_type dof_number(const unsigned int s, const unsigned int var, const unsigned int comp) const
const Elem * parent() const
constraint_rows_type & get_constraint_rows()
Constraint rows accessors.
A Node is like a Point, but with more information.
const unsigned int invalid_uint
A number which is used quite often to represent an invalid or uninitialized value for an unsigned int...
unsigned int n_comp(const unsigned int s, const unsigned int var) const
std::unique_ptr< PointLocatorBase > sub_point_locator() const
This class defines a sphere.
const Elem * interior_parent() const
The definition of the const_element_iterator struct.
const Elem * top_parent() const
Dummy "splitting object" used to distinguish splitting constructors from copy constructors.
This is the base class from which all geometric element types are derived.
void assign_global_indices(MeshBase &) const
This method assigns globally unique, partition-agnostic indices to the nodes and elements in the mesh...
virtual bool is_node_on_side(const unsigned int n, const unsigned int s) const =0
void skip_noncritical_partitioning(bool skip)
If true is passed in then the elements on this mesh will no longer be (re)partitioned, and the nodes on this mesh will only be repartitioned if they are found "orphaned" via coarsening or other removal of the last element responsible for their node/element processor id consistency.
unique_id_type unique_id() const
const Parallel::Communicator & comm() const
The StoredRange class defines a contiguous, divisible set of objects.
The libMesh namespace provides an interface to certain functionality in the library.
const BoundaryInfo & get_boundary_info() const
The information about boundary ids on the mesh.
virtual std::unique_ptr< MeshBase > clone() const =0
Virtual "copy constructor".
Real distance(const Point &p)
processor_id_type choose_processor_id(processor_id_type pid1, processor_id_type pid2) const
Return which of pid1 and pid2 would be preferred by the current load-balancing heuristic applied to t...
uint8_t processor_id_type
This is the MeshBase class.
SimpleRange< ChildRefIter > child_ref_range()
Returns a range with all children of a parent element, usable in range-based for loops.
virtual bool is_serial_on_zero() const
uint8_t processor_id_type
processor_id_type n_processors() const
virtual bool is_serial() const
void libmesh_ignore(const Args &...)
const dof_id_type n_nodes
static const boundary_id_type invalid_id
Number used for internal use.
virtual void delete_elem(Elem *e)=0
Removes element e from the mesh.
ElemMappingType mapping_type() const
This is the MeshCommunication class.
void min(const T &r, T &o, Request &req) const
virtual unsigned int n_nodes() const =0
static const processor_id_type invalid_processor_id
An invalid processor_id to distinguish DoFs that have not been assigned to a processor.
unsigned int n_vars(const unsigned int s, const unsigned int vg) const
unsigned int which_neighbor_am_i(const Elem *e) const
This function tells you which neighbor e is.
unsigned int n_systems() const
SimpleRange< IndexType > as_range(const std::pair< IndexType, IndexType > &p)
Helper function that allows us to treat a homogenous pair as a range.
virtual const Node * query_node_ptr(const dof_id_type i) const =0
virtual dof_id_type max_elem_id() const =0
The BoundaryInfo class contains information relevant to boundary conditions including storing faces...
static const dof_id_type invalid_id
An invalid id to distinguish an uninitialized DofObject.
virtual void delete_node(Node *n)=0
Removes the Node n from the mesh.
virtual unsigned int n_edges() const =0
timpi_pure bool semiverify(const T *r) const
void sync_dofobject_data_by_id(const Communicator &comm, const Iterator &range_begin, const Iterator &range_end, SyncFunctor &sync)
Request data about a range of ghost dofobjects uniquely identified by their id.
void broadcast(T &data, const unsigned int root_id=0, const bool identical_sizes=false) const
std::string enum_to_string(const T e)
Defines a Cartesian bounding box by the two corner extremum.
virtual const Elem * elem_ptr(const dof_id_type i) const =0
virtual unsigned int n_sides() const =0
const Elem * neighbor_ptr(unsigned int i) const
unsigned int level() const
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
virtual const Elem * query_elem_ptr(const dof_id_type i) const =0
timpi_pure bool verify(const T &r) const
void max(const T &r, T &o, Request &req) const
DIE A HORRIBLE DEATH HERE typedef MPI_Comm communicator
const Node * node_ptr(const unsigned int i) const
unsigned int n_neighbors() const
The definition of the const_node_iterator struct.
IntRange< T > make_range(T beg, T end)
The 2-parameter make_range() helper function returns an IntRange<T> when both input parameters are of...
The DofObject defines an abstract base class for objects that have degrees of freedom associated with...
unsigned int mesh_dimension() const
void parallel_reduce(const Range &range, Body &body)
Execute the provided reduction operation in parallel on the specified range.
IntRange< unsigned short > node_index_range() const
virtual const Node & node_ref(const dof_id_type i) const
virtual dof_id_type max_node_id() const =0
virtual dof_id_type n_elem() const =0
virtual const Node * node_ptr(const dof_id_type i) const =0
processor_id_type processor_id() const
processor_id_type processor_id() const
virtual ElemType type() const =0
A Point defines a location in LIBMESH_DIM dimensional Real space.
dof_id_type node_id(const unsigned int i) const
bool has_children() const
auto index_range(const T &sizable)
Helper function that returns an IntRange<std::size_t> representing all the indices of the passed-in v...
const RemoteElem * remote_elem