439 mesh->set_mesh_dimension(
_input->mesh_dimension() + 1);
450 " of 'elem_integer_names_to_swap' in is not a valid extra element integer of the "
454 const unsigned int num_extra_elem_integers =
_input->n_elem_integers();
455 std::vector<std::string> id_names;
457 for (
unsigned int i = 0; i < num_extra_elem_integers; i++)
459 id_names.push_back(
_input->get_elem_integer_name(i));
460 if (!
mesh->has_elem_integer(id_names[i]))
461 mesh->add_elem_integer(id_names[i]);
465 if (!
_input->preparation().has_cached_elem_data)
466 _input->cache_elem_data();
467 const auto & input_subdomain_map =
_input->get_subdomain_name_map();
468 const auto & input_sideset_map =
_input->get_boundary_info().get_sideset_name_map();
469 const auto & input_nodeset_map =
_input->get_boundary_info().get_nodeset_name_map();
473 for (
const auto i : index_range(swap))
478 blocks += (
blocks.empty() ?
"" :
", ") +
name +
" (" + std::to_string(
id) +
")";
482 "' was not found within the mesh.\nBlock names (ID) in the mesh: " +
blocks);
490 for (
const auto i : index_range(swap))
491 if (i % 2 == 1 && MooseUtils::isDigits(swap[i]))
492 next_free_subdomain_id = std::max(
493 next_free_subdomain_id,
495 std::map<SubdomainName, subdomain_id_type> new_subdomain_ids;
496 std::vector<std::vector<subdomain_id_type>> subdomain_swap_ids(
_subdomain_swaps.size());
501 if (i % 2 == 0 || MooseUtils::isDigits(subdomain) ||
506 if (!new_subdomain_ids.count(subdomain))
507 new_subdomain_ids[subdomain] = next_free_subdomain_id++;
508 subdomain_swap_ids[row].push_back(new_subdomain_ids[subdomain]);
524 for (
const auto i : index_range(swap))
529 "' was not found within the mesh.\nBoundaries in the mesh: " +
534 for (
const auto bid : layer_vec)
537 "upward_boundary_source_blocks",
"The block '", bid,
"' was not found within the mesh");
539 for (
const auto bid : layer_vec)
544 "' was not found within the mesh");
547 std::unique_ptr<MeshBase> input = std::move(
_input);
548 std::unique_ptr<MeshBase> extrusion_curve;
554 "Extruding along node normals is not implemented for non-serialized distributed "
558 std::unique_ptr<libMesh::MeshSerializer> serializer;
560 serializer = std::make_unique<libMesh::MeshSerializer>(*extrusion_curve);
564 input->find_neighbors();
568 if (!input->is_serial())
570 input->delete_remote_elements();
572 mesh->delete_remote_elements();
575 if (input->n_nodes() != input->max_node_id())
576 input->renumber_nodes_and_elements();
578 if (input->n_nodes() != input->max_node_id())
580 "You must allow renumbering, because the extruded mesh should be contiguously numbered. "
581 "Alternatively, you can use a separate mesh generator (MeshRepairGenerator with the "
582 "renumber_contiguously parameter for example) to renumber the nodes contiguously.");
584 unsigned int total_num_layers;
585 unsigned int total_num_elevations;
589 total_num_elevations =
_heights.size();
593 total_num_layers = extrusion_curve->n_elem();
594 total_num_elevations = 1;
597 dof_id_type orig_elem = input->n_elem();
598 dof_id_type orig_nodes = input->n_nodes();
600#ifdef LIBMESH_ENABLE_UNIQUE_ID
601 unique_id_type orig_unique_ids = input->parallel_max_unique_id();
602 bool has_poly_midnodes =
false;
605 bool has_polygons =
false;
606 unsigned int order = 1;
608 BoundaryInfo & boundary_info =
mesh->get_boundary_info();
609 const BoundaryInfo & input_boundary_info = input->get_boundary_info();
612 std::vector<BoundaryName> new_boundary_names;
619 std::vector<boundary_id_type> new_boundary_ids =
623 for (
const auto i : index_range(new_boundary_names))
624 for (
const auto j : make_range(i))
625 if (new_boundary_names[i] == new_boundary_names[j])
626 new_boundary_ids[i] = new_boundary_ids[j];
627 const auto user_bottom_boundary_id =
632 const auto user_side_boundary_id =
636 mesh->reserve_elem(total_num_layers * orig_elem);
639 std::set<ElemType> higher_orders = {EDGE3, EDGE4, TRI6, TRI7, QUAD8, QUAD9};
640 bool extruding_quad_eights =
false;
641 std::vector<ElemType> types;
643 for (
const auto elem_type : types)
645 if (higher_orders.count(elem_type))
647 if (elem_type == QUAD8)
648 extruding_quad_eights =
true;
650 mesh->comm().max(order);
651 mesh->comm().max(extruding_quad_eights);
654 mesh->reserve_nodes((order * total_num_layers + 1) * orig_nodes);
657 std::vector<boundary_id_type> ids_to_copy;
660 Real start_radial_extent = 0;
661 Point reference_point;
663 reference_point = *(extrusion_curve->node_ptr(0));
664 else if (!MooseUtils::absoluteFuzzyEqual(
_twist_pitch, 0.))
666 reference_point = Point(0, 0, 0);
674 RealVectorValue reference_direction;
676 reference_direction =
680 (*(extrusion_curve->node_ptr(1)) - *(extrusion_curve->node_ptr(0))).unit());
685 start_radial_extent =
690 Real total_extrusion_distance_at_axis;
693 if (!extrusion_curve->is_prepared())
694 extrusion_curve->prepare_for_use();
698 total_extrusion_distance_at_axis = std::accumulate(
_heights.begin(),
_heights.end(), 0);
702 std::unordered_map<dof_id_type, Point> node_normals;
707 for (
const auto & node : input->node_ptr_range())
709 unsigned int current_node_layer = 0;
710 Point orig_node_to_previous;
711 Point orig_node_to_current;
712 Real sum_step_sizes = 0.;
713 Real sum_step_sizes_at_axis = 0.;
715 Real start_node_radius = (*node - reference_point).norm();
722 auto it = node_normals.find(node->id());
723 if (it == node_normals.end())
726 " is not connected to any element with a well-defined normal; its extrusion "
727 "direction cannot be determined.");
728 node_extrude_direction = it->second;
732 for (
const auto e : make_range(total_num_elevations))
735 Real height = std::numeric_limits<Real>::max(), bias = std::numeric_limits<Real>::max();
738 num_layers = extrusion_curve->n_elem();
748 unsigned int num_heights_at_elevation = order * num_layers + (e == 0 ? 1 : 0);
753 for (
const auto k : make_range(num_heights_at_elevation))
757 if (e == 0 && k == 0)
758 orig_node_to_current.
zero();
766 Real step_size_at_axis = 0;
770 const Node * P_current = extrusion_curve->node_ptr(k);
772 const Node * P_prev = extrusion_curve->node_ptr(k - 1);
775 const auto old_node = orig_node_to_previous + *node;
776 RealVectorValue b_vec = old_node - *P_prev;
777 Real node_distance_to_curve = b_vec.norm();
783 RealVectorValue intersecting_plane_normal_vec;
788 const auto P_next = extrusion_curve->node_ptr(k + 1);
789 intersecting_plane_normal_vec =
792 else if (k < order * num_layers - 1)
794 const auto P_next = extrusion_curve->node_ptr(k + 1);
796 intersecting_plane_normal_vec = *P_next - *P_prev;
802 : RealVectorValue(*P_current - *P_prev);
804 intersecting_plane_normal_vec /= intersecting_plane_normal_vec.norm();
806 Point new_node_point;
809 if (MooseUtils::absoluteFuzzyEqual(
810 prev_intersecting_plane_normal_vec.cross(intersecting_plane_normal_vec)
813 new_node_point = old_node + *P_current - *P_prev;
821 auto axis = prev_intersecting_plane_normal_vec.cross(intersecting_plane_normal_vec);
822 const auto sin_th = axis.norm();
824 Real cos_th = prev_intersecting_plane_normal_vec * intersecting_plane_normal_vec;
826 const auto new_v = cos_th * b_vec + axis.cross(b_vec) * sin_th +
827 axis * (axis * b_vec) * (1. - cos_th);
829 mooseAssert(MooseUtils::absoluteFuzzyEqual(new_v.norm(), b_vec.norm()),
830 "Radial extent be conserved");
831 new_node_point = *P_current + new_v;
834 orig_node_to_current = new_node_point - *node;
836 step_size = (orig_node_to_current - orig_node_to_previous).norm();
837 step_size_at_axis = (*P_current - *P_prev).norm();
838 prev_intersecting_plane_normal_vec = intersecting_plane_normal_vec;
846 "Norm of direction vector is not 1!");
851 step_size = ((*P_current - (orig_node_to_previous + *node)) *
_direction);
852 step_size_at_axis = step_size;
853 orig_node_to_current = orig_node_to_previous +
_direction * step_size;
861 auto layer_index = (k - (e == 0 ? 1 : 0)) / order + 1;
862 step_size = MooseUtils::absoluteFuzzyEqual(bias, 1.0)
863 ? height / (Real)num_layers / (Real)order
864 : height *
std::pow(bias, (Real)(layer_index - 1)) * (1.0 - bias) /
865 (1.0 -
std::pow(bias, (Real)(num_layers))) / (Real)order;
866 step_size_at_axis = step_size;
868 orig_node_to_current = orig_node_to_previous + node_extrude_direction * step_size;
872 sum_step_sizes += step_size;
873 sum_step_sizes_at_axis += step_size_at_axis;
881 (sum_step_sizes_at_axis - step_size_at_axis) / total_extrusion_distance_at_axis;
882 Real t = sum_step_sizes_at_axis / total_extrusion_distance_at_axis;
885 RealVectorValue node_to_extrusion_axis;
887 node_to_extrusion_axis =
888 *node + orig_node_to_current - *(extrusion_curve->node_ptr(k));
890 else if (!MooseUtils::absoluteFuzzyEqual(
_twist_pitch, 0.))
891 node_to_extrusion_axis =
892 *node + orig_node_to_current - (reference_point +
_direction * sum_step_sizes);
896 node_to_extrusion_axis = *node - reference_point;
899 const auto radius_scaling = start_node_radius / start_radial_extent;
905 orig_node_to_current += (start_radial_extent * (radial_ratio_m1 - radial_ratio) +
907 radius_scaling * node_to_extrusion_axis.unit();
916 if (!MooseUtils::absoluteFuzzyEqual(twist1.norm(), .0))
917 twist1 /= twist1.norm();
934 Point extrusion_axis_at_elevation;
935 Point prev_extrusion_axis_at_elevation;
938 extrusion_axis_at_elevation = *extrusion_curve->node_ptr(k);
939 prev_extrusion_axis_at_elevation = *extrusion_curve->node_ptr(k - 1);
944 extrusion_axis_at_elevation = reference_point +
_direction * sum_step_sizes;
945 prev_extrusion_axis_at_elevation =
946 reference_point +
_direction * (sum_step_sizes - step_size);
950 twist *= (*node + orig_node_to_current - extrusion_axis_at_elevation).norm();
953 if (!MooseUtils::absoluteFuzzyEqual(twist1.norm(), .0))
954 orig_node_to_current += twist;
959 Node * new_node =
mesh->add_point(*node + orig_node_to_current,
960 node->id() + (current_node_layer * orig_nodes),
961 node->processor_id());
963#ifdef LIBMESH_ENABLE_UNIQUE_ID
967 const unique_id_type uid = (current_node_layer == 0)
970 (current_node_layer - 1) * (orig_elem + orig_nodes) +
972 new_node->set_unique_id(uid);
976 input_boundary_info.boundary_ids(node, ids_to_copy);
978 boundary_info.add_node(new_node, ids_to_copy);
980 for (
const auto & id_to_copy : ids_to_copy)
982 boundary_info.add_node(new_node,
988 orig_node_to_previous = orig_node_to_current;
989 current_node_layer++;
994 const auto & side_ids = input_boundary_info.get_side_boundary_ids();
996 boundary_id_type next_side_id =
997 side_ids.empty() ? 0 : cast_int<boundary_id_type>(*side_ids.rbegin() + 1);
1002 input->comm().max(next_side_id);
1007 while (user_side_boundary_id == next_side_id || user_side_boundary_id == next_side_id + 1)
1011 std::map<std::array<unsigned int, 3>, std::shared_ptr<libMesh::Polygon>> poly_extruded_sides;
1014 for (
const auto & elem : input->element_ptr_range())
1016 const ElemType etype = elem->type();
1019 libmesh_assert(!elem->parent());
1021 unsigned int current_layer = 0;
1023 for (
unsigned int e = 0; e != total_num_elevations; e++)
1027 for (
unsigned int k = 0; k != num_layers; ++k)
1029 std::unique_ptr<Elem> new_elem;
1030 bool is_flipped(
false);
1035 new_elem = std::make_unique<Quad4>();
1037 0,
mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * orig_nodes)));
1039 1,
mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * orig_nodes)));
1041 2,
mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer + 1) * orig_nodes)));
1043 3,
mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer + 1) * orig_nodes)));
1045 if (elem->neighbor_ptr(0) == remote_elem)
1046 new_elem->set_neighbor(3,
const_cast<RemoteElem *
>(remote_elem));
1047 if (elem->neighbor_ptr(1) == remote_elem)
1048 new_elem->set_neighbor(1,
const_cast<RemoteElem *
>(remote_elem));
1054 new_elem = std::make_unique<Quad9>();
1056 0,
mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
1058 1,
mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
1061 mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
1064 mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
1066 4,
mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
1069 mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
1072 mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
1075 mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
1078 mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
1080 if (elem->neighbor_ptr(0) == remote_elem)
1081 new_elem->set_neighbor(3,
const_cast<RemoteElem *
>(remote_elem));
1082 if (elem->neighbor_ptr(1) == remote_elem)
1083 new_elem->set_neighbor(1,
const_cast<RemoteElem *
>(remote_elem));
1089 new_elem = std::make_unique<Prism6>();
1091 0,
mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * orig_nodes)));
1093 1,
mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * orig_nodes)));
1095 2,
mesh->node_ptr(elem->node_ptr(2)->id() + (current_layer * orig_nodes)));
1097 3,
mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer + 1) * orig_nodes)));
1099 4,
mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer + 1) * orig_nodes)));
1101 5,
mesh->node_ptr(elem->node_ptr(2)->id() + ((current_layer + 1) * orig_nodes)));
1103 if (elem->neighbor_ptr(0) == remote_elem)
1104 new_elem->set_neighbor(1,
const_cast<RemoteElem *
>(remote_elem));
1105 if (elem->neighbor_ptr(1) == remote_elem)
1106 new_elem->set_neighbor(2,
const_cast<RemoteElem *
>(remote_elem));
1107 if (elem->neighbor_ptr(2) == remote_elem)
1108 new_elem->set_neighbor(3,
const_cast<RemoteElem *
>(remote_elem));
1110 if (new_elem->volume() < 0.0)
1122 new_elem = std::make_unique<Prism18>();
1124 0,
mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
1126 1,
mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
1128 2,
mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
1131 mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
1134 mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
1137 mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
1139 6,
mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
1141 7,
mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
1143 8,
mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
1146 mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
1149 mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
1152 mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
1155 mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
1158 mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
1161 mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
1164 mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
1167 mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 1) * orig_nodes)));
1170 mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 1) * orig_nodes)));
1172 if (elem->neighbor_ptr(0) == remote_elem)
1173 new_elem->set_neighbor(1,
const_cast<RemoteElem *
>(remote_elem));
1174 if (elem->neighbor_ptr(1) == remote_elem)
1175 new_elem->set_neighbor(2,
const_cast<RemoteElem *
>(remote_elem));
1176 if (elem->neighbor_ptr(2) == remote_elem)
1177 new_elem->set_neighbor(3,
const_cast<RemoteElem *
>(remote_elem));
1179 if (new_elem->volume() < 0.0)
1194 new_elem = std::make_unique<Prism21>();
1196 0,
mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
1198 1,
mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
1200 2,
mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
1203 mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
1206 mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
1209 mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
1211 6,
mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
1213 7,
mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
1215 8,
mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
1218 mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
1221 mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
1224 mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
1227 mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
1230 mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
1233 mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
1236 mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
1239 mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 1) * orig_nodes)));
1242 mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 1) * orig_nodes)));
1244 18,
mesh->node_ptr(elem->node_ptr(6)->id() + (2 * current_layer * orig_nodes)));
1247 mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 2) * orig_nodes)));
1250 mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 1) * orig_nodes)));
1252 if (elem->neighbor_ptr(0) == remote_elem)
1253 new_elem->set_neighbor(1,
const_cast<RemoteElem *
>(remote_elem));
1254 if (elem->neighbor_ptr(1) == remote_elem)
1255 new_elem->set_neighbor(2,
const_cast<RemoteElem *
>(remote_elem));
1256 if (elem->neighbor_ptr(2) == remote_elem)
1257 new_elem->set_neighbor(3,
const_cast<RemoteElem *
>(remote_elem));
1259 if (new_elem->volume() < 0.0)
1275 new_elem = std::make_unique<Hex8>();
1277 0,
mesh->node_ptr(elem->node_ptr(0)->id() + (current_layer * orig_nodes)));
1279 1,
mesh->node_ptr(elem->node_ptr(1)->id() + (current_layer * orig_nodes)));
1281 2,
mesh->node_ptr(elem->node_ptr(2)->id() + (current_layer * orig_nodes)));
1283 3,
mesh->node_ptr(elem->node_ptr(3)->id() + (current_layer * orig_nodes)));
1285 4,
mesh->node_ptr(elem->node_ptr(0)->id() + ((current_layer + 1) * orig_nodes)));
1287 5,
mesh->node_ptr(elem->node_ptr(1)->id() + ((current_layer + 1) * orig_nodes)));
1289 6,
mesh->node_ptr(elem->node_ptr(2)->id() + ((current_layer + 1) * orig_nodes)));
1291 7,
mesh->node_ptr(elem->node_ptr(3)->id() + ((current_layer + 1) * orig_nodes)));
1293 if (elem->neighbor_ptr(0) == remote_elem)
1294 new_elem->set_neighbor(1,
const_cast<RemoteElem *
>(remote_elem));
1295 if (elem->neighbor_ptr(1) == remote_elem)
1296 new_elem->set_neighbor(2,
const_cast<RemoteElem *
>(remote_elem));
1297 if (elem->neighbor_ptr(2) == remote_elem)
1298 new_elem->set_neighbor(3,
const_cast<RemoteElem *
>(remote_elem));
1299 if (elem->neighbor_ptr(3) == remote_elem)
1300 new_elem->set_neighbor(4,
const_cast<RemoteElem *
>(remote_elem));
1302 if (new_elem->volume() < 0.0)
1315 new_elem = std::make_unique<Hex20>();
1317 0,
mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
1319 1,
mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
1321 2,
mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
1323 3,
mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
1326 mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
1329 mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
1332 mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
1335 mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
1337 8,
mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
1339 9,
mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
1341 10,
mesh->node_ptr(elem->node_ptr(6)->id() + (2 * current_layer * orig_nodes)));
1343 11,
mesh->node_ptr(elem->node_ptr(7)->id() + (2 * current_layer * orig_nodes)));
1346 mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
1349 mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
1352 mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
1355 mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
1358 mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
1361 mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
1364 mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 2) * orig_nodes)));
1367 mesh->node_ptr(elem->node_ptr(7)->id() + ((2 * current_layer + 2) * orig_nodes)));
1369 if (elem->neighbor_ptr(0) == remote_elem)
1370 new_elem->set_neighbor(1,
const_cast<RemoteElem *
>(remote_elem));
1371 if (elem->neighbor_ptr(1) == remote_elem)
1372 new_elem->set_neighbor(2,
const_cast<RemoteElem *
>(remote_elem));
1373 if (elem->neighbor_ptr(2) == remote_elem)
1374 new_elem->set_neighbor(3,
const_cast<RemoteElem *
>(remote_elem));
1375 if (elem->neighbor_ptr(3) == remote_elem)
1376 new_elem->set_neighbor(4,
const_cast<RemoteElem *
>(remote_elem));
1378 if (new_elem->volume() < 0.0)
1395 new_elem = std::make_unique<Hex27>();
1397 0,
mesh->node_ptr(elem->node_ptr(0)->id() + (2 * current_layer * orig_nodes)));
1399 1,
mesh->node_ptr(elem->node_ptr(1)->id() + (2 * current_layer * orig_nodes)));
1401 2,
mesh->node_ptr(elem->node_ptr(2)->id() + (2 * current_layer * orig_nodes)));
1403 3,
mesh->node_ptr(elem->node_ptr(3)->id() + (2 * current_layer * orig_nodes)));
1406 mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 2) * orig_nodes)));
1409 mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 2) * orig_nodes)));
1412 mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 2) * orig_nodes)));
1415 mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 2) * orig_nodes)));
1417 8,
mesh->node_ptr(elem->node_ptr(4)->id() + (2 * current_layer * orig_nodes)));
1419 9,
mesh->node_ptr(elem->node_ptr(5)->id() + (2 * current_layer * orig_nodes)));
1421 10,
mesh->node_ptr(elem->node_ptr(6)->id() + (2 * current_layer * orig_nodes)));
1423 11,
mesh->node_ptr(elem->node_ptr(7)->id() + (2 * current_layer * orig_nodes)));
1426 mesh->node_ptr(elem->node_ptr(0)->id() + ((2 * current_layer + 1) * orig_nodes)));
1429 mesh->node_ptr(elem->node_ptr(1)->id() + ((2 * current_layer + 1) * orig_nodes)));
1432 mesh->node_ptr(elem->node_ptr(2)->id() + ((2 * current_layer + 1) * orig_nodes)));
1435 mesh->node_ptr(elem->node_ptr(3)->id() + ((2 * current_layer + 1) * orig_nodes)));
1438 mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 2) * orig_nodes)));
1441 mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 2) * orig_nodes)));
1444 mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 2) * orig_nodes)));
1447 mesh->node_ptr(elem->node_ptr(7)->id() + ((2 * current_layer + 2) * orig_nodes)));
1449 20,
mesh->node_ptr(elem->node_ptr(8)->id() + (2 * current_layer * orig_nodes)));
1452 mesh->node_ptr(elem->node_ptr(4)->id() + ((2 * current_layer + 1) * orig_nodes)));
1455 mesh->node_ptr(elem->node_ptr(5)->id() + ((2 * current_layer + 1) * orig_nodes)));
1458 mesh->node_ptr(elem->node_ptr(6)->id() + ((2 * current_layer + 1) * orig_nodes)));
1461 mesh->node_ptr(elem->node_ptr(7)->id() + ((2 * current_layer + 1) * orig_nodes)));
1464 mesh->node_ptr(elem->node_ptr(8)->id() + ((2 * current_layer + 2) * orig_nodes)));
1467 mesh->node_ptr(elem->node_ptr(8)->id() + ((2 * current_layer + 1) * orig_nodes)));
1469 if (elem->neighbor_ptr(0) == remote_elem)
1470 new_elem->set_neighbor(1,
const_cast<RemoteElem *
>(remote_elem));
1471 if (elem->neighbor_ptr(1) == remote_elem)
1472 new_elem->set_neighbor(2,
const_cast<RemoteElem *
>(remote_elem));
1473 if (elem->neighbor_ptr(2) == remote_elem)
1474 new_elem->set_neighbor(3,
const_cast<RemoteElem *
>(remote_elem));
1475 if (elem->neighbor_ptr(3) == remote_elem)
1476 new_elem->set_neighbor(4,
const_cast<RemoteElem *
>(remote_elem));
1478 if (new_elem->volume() < 0.0)
1496 has_polygons =
true;
1497 const auto num_sides = elem->n_sides();
1498 std::vector<std::shared_ptr<libMesh::Polygon>>
sides;
1499 sides.reserve(2 + num_sides);
1501 mooseError(
"Too many nodes in polygons to extrude it. Max number of the prism "
1502 "polyhedral nodes after extrusion: " +
1505 auto new_ptr = std::make_shared<libMesh::C0Polygon>(num_sides);
1506 for (
const auto node_i : make_range(elem->n_nodes()))
1512 mesh->node_ptr(elem->node_ptr(node_i)->id() + (current_layer * orig_nodes)));
1514 sides.push_back(new_ptr);
1516 auto translated_side = std::make_shared<libMesh::C0Polygon>(num_sides);
1517 for (
const auto node_i : make_range(elem->n_nodes()))
1518 translated_side->set_node(node_i,
1519 mesh->node_ptr(elem->node_ptr(node_i)->id() +
1520 ((current_layer + 1) * orig_nodes)));
1521 sides.push_back(translated_side);
1524 for (
const auto side_i : make_range(num_sides))
1527 std::array<unsigned int, 3> side_key = {
1529 static_cast<unsigned int>(
1530 std::min(elem->node_ptr(side_i)->id(),
1531 elem->node_ptr((side_i + 1) % num_sides)->id())),
1532 static_cast<unsigned int>(
1533 std::max(elem->node_ptr(side_i)->id(),
1534 elem->node_ptr((side_i + 1) % num_sides)->id()))};
1535 if (poly_extruded_sides.count(side_key))
1537 sides.push_back(poly_extruded_sides[side_key]);
1542 auto vert_side = std::make_shared<libMesh::C0Polygon>(4);
1543 vert_side->set_node(
1544 0,
mesh->node_ptr(elem->node_ptr(side_i)->id() + (current_layer * orig_nodes)));
1545 vert_side->set_node(1,
1546 mesh->node_ptr(elem->node_ptr((side_i + 1) % num_sides)->id() +
1547 (current_layer * orig_nodes)));
1548 vert_side->set_node(2,
1549 mesh->node_ptr(elem->node_ptr((side_i + 1) % num_sides)->id() +
1550 ((current_layer + 1) * orig_nodes)));
1551 vert_side->set_node(3,
1552 mesh->node_ptr(elem->node_ptr(side_i)->id() +
1553 ((current_layer + 1) * orig_nodes)));
1554 sides.push_back(vert_side);
1556 poly_extruded_sides.insert(std::make_pair(side_key, vert_side));
1558 mooseAssert(
sides.size() == 2 + num_sides,
"Unexpected size of side vector");
1561 std::unique_ptr<libMesh::Node> mid_elem_node;
1562 new_elem = std::make_unique<libMesh::C0Polyhedron>(
sides, mid_elem_node);
1565#ifdef LIBMESH_ENABLE_UNIQUE_ID
1568 unsigned int total_new_node_layers = total_num_layers * order;
1569 unsigned int last_uid = orig_unique_ids + (total_new_node_layers - 1) * orig_elem +
1570 total_new_node_layers * orig_nodes + elem->unique_id();
1571 mid_elem_node->set_unique_id(last_uid);
1572 has_poly_midnodes =
true;
1574 mesh->add_node(std::move(mid_elem_node));
1583 new_elem->set_id(elem->id() + (current_layer * orig_elem));
1584 new_elem->processor_id() = elem->processor_id();
1586#ifdef LIBMESH_ENABLE_UNIQUE_ID
1590 const unique_id_type uid = (current_layer == 0)
1593 (current_layer - 1) * (orig_elem + orig_nodes) +
1594 orig_nodes + elem->id();
1596 new_elem->set_unique_id(uid);
1600 new_elem->subdomain_id() = elem->subdomain_id();
1603 if (k == num_layers - 1)
1606 const unsigned short top_id =
1607 new_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
1613 boundary_info.add_side(
1619 const unsigned short top_id =
1620 new_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
1624 boundary_info.add_side(
1633 auto new_id_it = elevation_swap_pairs.find(elem->subdomain_id());
1635 if (new_id_it != elevation_swap_pairs.end())
1636 new_elem->subdomain_id() = new_id_it->second;
1639 Elem * added_elem =
mesh->add_elem(std::move(new_elem));
1642 for (
unsigned int i = 0; i < num_extra_elem_integers; i++)
1643 added_elem->set_extra_integer(i, elem->get_extra_integer(i));
1651 auto new_extra_id_it = elevation_extra_swap_pairs.find(
1654 if (new_extra_id_it != elevation_extra_swap_pairs.end())
1656 new_extra_id_it->second);
1661 for (
auto s : elem->side_index_range())
1663 input_boundary_info.boundary_ids(elem, s, ids_to_copy);
1665 if (added_elem->dim() == 3)
1672 boundary_info.add_side(added_elem, cast_int<unsigned short>(s + 1), ids_to_copy);
1674 for (
const auto & id_to_copy : ids_to_copy)
1675 boundary_info.add_side(added_elem,
1676 cast_int<unsigned short>(s + 1),
1687 libmesh_assert_less(s, 2);
1688 const unsigned short sidemap[2] = {3, 1};
1690 boundary_info.add_side(added_elem, sidemap[s], ids_to_copy);
1692 for (
const auto & id_to_copy : ids_to_copy)
1693 boundary_info.add_side(added_elem,
1703 const unsigned short new_side =
1704 added_elem->dim() == 3 ? cast_int<unsigned short>(s + 1) : (s == 0 ? 3 : 1);
1705 boundary_info.add_side(added_elem, new_side, user_side_boundary_id);
1706 for (
const auto n : added_elem->nodes_on_side(new_side))
1707 boundary_info.add_node(added_elem->node_ptr(n), user_side_boundary_id);
1712 if (current_layer == 0)
1714 const unsigned short top_id =
1715 added_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
1719 "We should have retrieved a proper boundary ID");
1720 boundary_info.add_side(added_elem, is_flipped ?
top_id : 0, user_bottom_boundary_id);
1723 boundary_info.add_side(added_elem, is_flipped ?
top_id : 0, next_side_id);
1726 if (current_layer == total_num_layers - 1)
1731 const unsigned short top_id =
1732 added_elem->dim() == 3 ? cast_int<unsigned short>(elem->n_sides() + 1) : 2;
1737 "We should have retrieved a proper boundary ID");
1738 boundary_info.add_side(added_elem, is_flipped ? 0 :
top_id, user_top_boundary_id);
1741 boundary_info.add_side(
1742 added_elem, is_flipped ? 0 :
top_id, cast_int<boundary_id_type>(next_side_id + 1));
1750 if (has_polygons && !input->is_serial())
1751 mooseError(
"Distributed meshes are not supported when extruding polygons at this time.");
1753#ifdef LIBMESH_ENABLE_UNIQUE_ID
1756 unsigned int total_new_node_layers = total_num_layers * order;
1757 unsigned int new_unique_ids = orig_unique_ids + (total_new_node_layers - 1) * orig_elem +
1758 total_new_node_layers * orig_nodes;
1760 if (has_poly_midnodes)
1761 new_unique_ids += orig_elem;
1762 mesh->set_next_unique_id(new_unique_ids);
1766 if (!input_subdomain_map.empty())
1767 mesh->set_subdomain_name_map().insert(input_subdomain_map.begin(), input_subdomain_map.end());
1768 for (
const auto & [subdomain_name, subdomain_id] : new_subdomain_ids)
1769 mesh->set_subdomain_name(subdomain_id, subdomain_name,
true);
1770 if (!input_sideset_map.empty())
1771 mesh->get_boundary_info().set_sideset_name_map().insert(input_sideset_map.begin(),
1772 input_sideset_map.end());
1773 if (!input_nodeset_map.empty())
1774 mesh->get_boundary_info().set_nodeset_name_map().insert(input_nodeset_map.begin(),
1775 input_nodeset_map.end());
1777 for (
const auto i : index_range(new_boundary_names))
1778 boundary_info.sideset_name(new_boundary_ids[i]) = new_boundary_names[i];
1780 boundary_info.nodeset_name(user_side_boundary_id) =
_side_boundary;
1782 mesh->unset_is_prepared();
1785 if (extruding_quad_eights)
1786 mesh->prepare_for_use();