Line data Source code
1 : // The libMesh Finite Element Library.
2 : // Copyright (C) 2002-2026 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
3 :
4 : // This library is free software; you can redistribute it and/or
5 : // modify it under the terms of the GNU Lesser General Public
6 : // License as published by the Free Software Foundation; either
7 : // version 2.1 of the License, or (at your option) any later version.
8 :
9 : // This library is distributed in the hope that it will be useful,
10 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 : // Lesser General Public License for more details.
13 :
14 : // You should have received a copy of the GNU Lesser General Public
15 : // License along with this library; if not, write to the Free Software
16 : // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 :
18 :
19 :
20 : // libmesh includes
21 : #include "libmesh/mesh_generation.h"
22 : #include "libmesh/unstructured_mesh.h"
23 : #include "libmesh/mesh_refinement.h"
24 : #include "libmesh/edge_edge2.h"
25 : #include "libmesh/edge_edge3.h"
26 : #include "libmesh/edge_edge4.h"
27 : #include "libmesh/face_tri3.h"
28 : #include "libmesh/face_tri6.h"
29 : #include "libmesh/face_tri7.h"
30 : #include "libmesh/face_quad4.h"
31 : #include "libmesh/face_quad8.h"
32 : #include "libmesh/face_quad9.h"
33 : #include "libmesh/face_c0polygon.h"
34 : #include "libmesh/cell_c0polyhedron.h"
35 : #include "libmesh/cell_hex8.h"
36 : #include "libmesh/cell_hex20.h"
37 : #include "libmesh/cell_hex27.h"
38 : #include "libmesh/cell_prism6.h"
39 : #include "libmesh/cell_prism15.h"
40 : #include "libmesh/cell_prism18.h"
41 : #include "libmesh/cell_prism20.h"
42 : #include "libmesh/cell_prism21.h"
43 : #include "libmesh/cell_tet4.h"
44 : #include "libmesh/cell_pyramid5.h"
45 : #include "libmesh/libmesh_logging.h"
46 : #include "libmesh/boundary_info.h"
47 : #include "libmesh/remote_elem.h"
48 : #include "libmesh/sphere.h"
49 : #include "libmesh/mesh_modification.h"
50 : #include "libmesh/mesh_smoother_laplace.h"
51 : #include "libmesh/node_elem.h"
52 : #include "libmesh/vector_value.h"
53 : #include "libmesh/function_base.h"
54 : #include "libmesh/enum_order.h"
55 : #include "libmesh/int_range.h"
56 : #include "libmesh/parallel.h"
57 : #include "libmesh/parallel_ghost_sync.h"
58 : #include "libmesh/enum_to_string.h"
59 : #include "libmesh/node_range.h"
60 :
61 : // C++ includes
62 : #include <array>
63 : #include <cstdlib> // *must* precede <cmath> for proper std:abs() on PGI, Sun Studio CC
64 : #include <cmath> // for std::sqrt
65 : #include <unordered_set>
66 :
67 :
68 : namespace libMesh
69 : {
70 :
71 : namespace MeshTools {
72 : namespace Generation {
73 : namespace Private {
74 : /**
75 : * A useful inline function which replaces the macros
76 : * used previously. Not private since this is a namespace,
77 : * but would be if this were a class. The first one returns
78 : * the proper node number for 2D elements while the second
79 : * one returns the node number for 3D elements.
80 : */
81 : inline
82 1644282 : unsigned int idx(const ElemType type,
83 : const unsigned int nx,
84 : const unsigned int i,
85 : const unsigned int j)
86 : {
87 1184736 : switch(type)
88 : {
89 330922 : case INVALID_ELEM:
90 : case QUAD4:
91 : case QUADSHELL4:
92 : case TRI3:
93 : case TRISHELL3:
94 : {
95 330922 : return i + j*(nx+1);
96 : }
97 :
98 1301040 : case QUAD8:
99 : case QUADSHELL8:
100 : case QUAD9:
101 : case QUADSHELL9:
102 : case TRI6:
103 : case TRI7:
104 : {
105 1301040 : return i + j*(2*nx+1);
106 : }
107 :
108 12320 : case QUAD16:
109 : {
110 12320 : return i + j*(3*nx+1);
111 : }
112 :
113 0 : default:
114 0 : libmesh_error_msg("ERROR: Unrecognized 2D element type == " << Utility::enum_to_string(type));
115 : }
116 :
117 : return libMesh::invalid_uint;
118 : }
119 :
120 :
121 :
122 : // Same as the function above, but for 3D elements
123 : inline
124 4399277 : unsigned int idx(const ElemType type,
125 : const unsigned int nx,
126 : const unsigned int ny,
127 : const unsigned int i,
128 : const unsigned int j,
129 : const unsigned int k)
130 : {
131 3189291 : switch(type)
132 : {
133 860504 : case INVALID_ELEM:
134 : case HEX8:
135 : case PRISM6:
136 : case C0POLYHEDRON:
137 : {
138 860504 : return i + (nx+1)*(j + k*(ny+1));
139 : }
140 :
141 3538773 : case HEX20:
142 : case HEX27:
143 : case TET4: // TET4's are created from an initial HEX27 discretization
144 : case TET10: // TET10's are created from an initial HEX27 discretization
145 : case TET14: // TET14's are created from an initial HEX27 discretization
146 : case PYRAMID5: // PYRAMID5's are created from an initial HEX27 discretization
147 : case PYRAMID13:
148 : case PYRAMID14:
149 : case PYRAMID18:
150 : case PRISM15:
151 : case PRISM18:
152 : case PRISM20:
153 : case PRISM21:
154 : {
155 3538773 : return i + (2*nx+1)*(j + k*(2*ny+1));
156 : }
157 :
158 0 : default:
159 0 : libmesh_error_msg("ERROR: Unrecognized element type == " << Utility::enum_to_string(type));
160 : }
161 :
162 : return libMesh::invalid_uint;
163 : }
164 :
165 :
166 : /**
167 : * This object is passed to MeshTools::Modification::redistribute() to
168 : * redistribute the points on a uniform grid into the Gauss-Lobatto
169 : * points on the actual grid.
170 : */
171 : class GaussLobattoRedistributionFunction : public FunctionBase<Real>
172 : {
173 : public:
174 : /**
175 : * Constructor.
176 : */
177 0 : GaussLobattoRedistributionFunction(unsigned int nx,
178 : Real xmin,
179 : Real xmax,
180 : unsigned int ny=0,
181 : Real ymin=0,
182 : Real ymax=0,
183 : unsigned int nz=0,
184 : Real zmin=0,
185 0 : Real zmax=0) :
186 0 : FunctionBase<Real>(nullptr)
187 : {
188 0 : _nelem.resize(3);
189 0 : _nelem[0] = nx;
190 0 : _nelem[1] = ny;
191 0 : _nelem[2] = nz;
192 :
193 0 : _mins.resize(3);
194 0 : _mins[0] = xmin;
195 0 : _mins[1] = ymin;
196 0 : _mins[2] = zmin;
197 :
198 0 : _widths.resize(3);
199 0 : _widths[0] = xmax - xmin;
200 0 : _widths[1] = ymax - ymin;
201 0 : _widths[2] = zmax - zmin;
202 :
203 : // Precompute the cosine values.
204 0 : _cosines.resize(3);
205 0 : for (unsigned dir=0; dir<3; ++dir)
206 0 : if (_nelem[dir] != 0)
207 : {
208 0 : _cosines[dir].resize(_nelem[dir]+1);
209 0 : for (auto i : index_range(_cosines[dir]))
210 0 : _cosines[dir][i] = std::cos(libMesh::pi * Real(i) / _nelem[dir]);
211 : }
212 0 : }
213 :
214 : /**
215 : * The 5 special functions can be defaulted for this class.
216 : */
217 : GaussLobattoRedistributionFunction (GaussLobattoRedistributionFunction &&) = default;
218 0 : GaussLobattoRedistributionFunction (const GaussLobattoRedistributionFunction &) = default;
219 : GaussLobattoRedistributionFunction & operator= (const GaussLobattoRedistributionFunction &) = default;
220 : GaussLobattoRedistributionFunction & operator= (GaussLobattoRedistributionFunction &&) = default;
221 0 : virtual ~GaussLobattoRedistributionFunction () = default;
222 :
223 : /**
224 : * We must provide a way to clone ourselves to satisfy the pure
225 : * virtual interface. We use the autogenerated copy constructor.
226 : */
227 0 : virtual std::unique_ptr<FunctionBase<Real>> clone () const override
228 : {
229 0 : return std::make_unique<GaussLobattoRedistributionFunction>(*this);
230 : }
231 :
232 : /**
233 : * This is the actual function that
234 : * MeshTools::Modification::redistribute() calls. Moves the points
235 : * of the grid to the Gauss-Lobatto points.
236 : */
237 0 : virtual void operator() (const Point & p,
238 : const Real /*time*/,
239 : DenseVector<Real> & output) override
240 : {
241 0 : output.resize(3);
242 :
243 0 : for (unsigned dir=0; dir<3; ++dir)
244 0 : if (_nelem[dir] != 0)
245 : {
246 : // Figure out the index of the current point.
247 0 : Real float_index = (p(dir) - _mins[dir]) * _nelem[dir] / _widths[dir];
248 :
249 : // std::modf separates the fractional and integer parts of the index.
250 0 : Real integer_part_f = 0;
251 0 : const Real fractional_part = std::modf(float_index, &integer_part_f);
252 :
253 0 : const int integer_part = int(integer_part_f);
254 :
255 : // Vertex node?
256 0 : if (std::abs(fractional_part) < TOLERANCE || std::abs(fractional_part - 1.0) < TOLERANCE)
257 : {
258 0 : int index = int(round(float_index));
259 :
260 : // Move node to the Gauss-Lobatto position.
261 0 : output(dir) = _mins[dir] + _widths[dir] * 0.5 * (1.0 - _cosines[dir][index]);
262 : }
263 :
264 : // Mid-edge (quadratic) node?
265 0 : else if (std::abs(fractional_part - 0.5) < TOLERANCE)
266 : {
267 : // Move node to the Gauss-Lobatto position, which is the average of
268 : // the node to the left and the node to the right.
269 0 : output(dir) = _mins[dir] + _widths[dir] * 0.5 *
270 0 : (1.0 - 0.5*(_cosines[dir][integer_part] + _cosines[dir][integer_part+1]));
271 : }
272 :
273 : // 1D only: Left interior (cubic) node?
274 0 : else if (std::abs(fractional_part - 1./3.) < TOLERANCE)
275 : {
276 : // Move node to the Gauss-Lobatto position, which is
277 : // 2/3*left_vertex + 1/3*right_vertex.
278 0 : output(dir) = _mins[dir] + _widths[dir] * 0.5 *
279 0 : (1.0 - 2./3.*_cosines[dir][integer_part] - 1./3.*_cosines[dir][integer_part+1]);
280 : }
281 :
282 : // 1D only: Right interior (cubic) node?
283 0 : else if (std::abs(fractional_part - 2./3.) < TOLERANCE)
284 : {
285 : // Move node to the Gauss-Lobatto position, which is
286 : // 1/3*left_vertex + 2/3*right_vertex.
287 0 : output(dir) = _mins[dir] + _widths[dir] * 0.5 *
288 0 : (1.0 - 1./3.*_cosines[dir][integer_part] - 2./3.*_cosines[dir][integer_part+1]);
289 : }
290 :
291 : else
292 0 : libmesh_error_msg("Cannot redistribute node: " << p);
293 : }
294 0 : }
295 :
296 : /**
297 : * We must also override operator() which returns a Real, but this function
298 : * should never be called, so it's left unimplemented.
299 : */
300 0 : virtual Real operator() (const Point & /*p*/,
301 : const Real /*time*/) override
302 : {
303 0 : libmesh_not_implemented();
304 : }
305 :
306 : protected:
307 : // Stored data
308 : std::vector<Real> _mins;
309 : std::vector<unsigned int> _nelem;
310 : std::vector<Real> _widths;
311 :
312 : // Precomputed values
313 : std::vector<std::vector<Real>> _cosines;
314 : };
315 :
316 :
317 : } // namespace Private
318 : } // namespace Generation
319 : } // namespace MeshTools
320 :
321 : // ------------------------------------------------------------
322 : // MeshTools::Generation function for mesh generation
323 45414 : void MeshTools::Generation::build_cube(UnstructuredMesh & mesh,
324 : const unsigned int nx,
325 : const unsigned int ny,
326 : const unsigned int nz,
327 : const Real xmin, const Real xmax,
328 : const Real ymin, const Real ymax,
329 : const Real zmin, const Real zmax,
330 : const ElemType type,
331 : const bool gauss_lobatto_grid)
332 : {
333 38991 : LOG_SCOPE("build_cube()", "MeshTools::Generation");
334 :
335 : // Declare that we are using the indexing utility routine
336 : // in the "Private" part of our current namespace. If this doesn't
337 : // work in GCC 2.95.3 we can either remove it or stop supporting
338 : // 2.95.3 altogether.
339 : // Changing this to import the whole namespace... just importing idx
340 : // causes an internal compiler error for Intel Compiler 11.0 on Linux
341 : // in debug mode.
342 : using namespace MeshTools::Generation::Private;
343 :
344 : // Clear the mesh and start from scratch
345 45414 : mesh.clear();
346 :
347 12997 : BoundaryInfo & boundary_info = mesh.get_boundary_info();
348 :
349 45414 : if (nz != 0)
350 : {
351 20624 : mesh.set_mesh_dimension(3);
352 20624 : mesh.set_spatial_dimension(3);
353 : }
354 24790 : else if (ny != 0)
355 : {
356 17615 : mesh.set_mesh_dimension(2);
357 17615 : mesh.set_spatial_dimension(2);
358 : }
359 7175 : else if (nx != 0)
360 : {
361 6884 : mesh.set_mesh_dimension(1);
362 6884 : mesh.set_spatial_dimension(1);
363 : }
364 : else
365 : {
366 : // Will we get here?
367 291 : mesh.set_mesh_dimension(0);
368 291 : mesh.set_spatial_dimension(0);
369 : }
370 :
371 45414 : switch (mesh.mesh_dimension())
372 : {
373 : //---------------------------------------------------------------------
374 : // Build a 0D point
375 291 : case 0:
376 : {
377 84 : libmesh_assert_equal_to (nx, 0);
378 84 : libmesh_assert_equal_to (ny, 0);
379 84 : libmesh_assert_equal_to (nz, 0);
380 :
381 84 : libmesh_assert (type == INVALID_ELEM || type == NODEELEM);
382 :
383 : // Build one nodal element for the mesh
384 375 : mesh.add_point (Point(0, 0, 0), 0);
385 291 : Elem * elem = mesh.add_elem(Elem::build(NODEELEM));
386 291 : elem->set_node(0, mesh.node_ptr(0));
387 :
388 207 : break;
389 : }
390 :
391 :
392 :
393 : //---------------------------------------------------------------------
394 : // Build a 1D line
395 6884 : case 1:
396 : {
397 1970 : libmesh_assert_not_equal_to (nx, 0);
398 1970 : libmesh_assert_equal_to (ny, 0);
399 1970 : libmesh_assert_equal_to (nz, 0);
400 1970 : libmesh_assert_less (xmin, xmax);
401 :
402 : // Reserve elements
403 : switch (type)
404 : {
405 6884 : case INVALID_ELEM:
406 : case EDGE2:
407 : case EDGE3:
408 : case EDGE4:
409 : {
410 6884 : mesh.reserve_elem (nx);
411 1970 : break;
412 : }
413 :
414 0 : default:
415 0 : libmesh_error_msg("ERROR: Unrecognized 1D element type == " << Utility::enum_to_string(type));
416 : }
417 :
418 : // Reserve nodes
419 : switch (type)
420 : {
421 2253 : case INVALID_ELEM:
422 : case EDGE2:
423 : {
424 2253 : mesh.reserve_nodes(nx+1);
425 1607 : break;
426 : }
427 :
428 3777 : case EDGE3:
429 : {
430 3777 : mesh.reserve_nodes(2*nx+1);
431 2697 : break;
432 : }
433 :
434 854 : case EDGE4:
435 : {
436 854 : mesh.reserve_nodes(3*nx+1);
437 610 : break;
438 : }
439 :
440 0 : default:
441 0 : libmesh_error_msg("ERROR: Unrecognized 1D element type == " << Utility::enum_to_string(type));
442 : }
443 :
444 :
445 : // Build the nodes, depends on whether we're using linears,
446 : // quadratics or cubics and whether using uniform grid or Gauss-Lobatto
447 1970 : unsigned int node_id = 0;
448 : switch(type)
449 : {
450 646 : case INVALID_ELEM:
451 : case EDGE2:
452 : {
453 32967 : for (unsigned int i=0; i<=nx; i++)
454 : {
455 40678 : const Node * const node = mesh.add_point (Point(static_cast<Real>(i)/nx, 0, 0), node_id++);
456 30714 : if (i == 0)
457 2253 : boundary_info.add_node(node, 0);
458 30714 : if (i == nx)
459 2253 : boundary_info.add_node(node, 1);
460 : }
461 :
462 646 : break;
463 : }
464 :
465 1080 : case EDGE3:
466 : {
467 18288 : for (unsigned int i=0; i<=2*nx; i++)
468 : {
469 18675 : const Node * const node = mesh.add_point (Point(static_cast<Real>(i)/(2*nx), 0, 0), node_id++);
470 14511 : if (i == 0)
471 3777 : boundary_info.add_node(node, 0);
472 14511 : if (i == 2*nx)
473 3777 : boundary_info.add_node(node, 1);
474 : }
475 1080 : break;
476 : }
477 :
478 244 : case EDGE4:
479 : {
480 5467 : for (unsigned int i=0; i<=3*nx; i++)
481 : {
482 5931 : const Node * const node = mesh.add_point (Point(static_cast<Real>(i)/(3*nx), 0, 0), node_id++);
483 4613 : if (i == 0)
484 854 : boundary_info.add_node(node, 0);
485 4613 : if (i == 3*nx)
486 854 : boundary_info.add_node(node, 1);
487 : }
488 :
489 244 : break;
490 : }
491 :
492 0 : default:
493 0 : libmesh_error_msg("ERROR: Unrecognized 1D element type == " << Utility::enum_to_string(type));
494 :
495 : }
496 :
497 : // Build the elements of the mesh
498 : switch(type)
499 : {
500 646 : case INVALID_ELEM:
501 : case EDGE2:
502 : {
503 30714 : for (unsigned int i=0; i<nx; i++)
504 : {
505 28461 : Elem * elem = mesh.add_elem(Elem::build_with_id(EDGE2, i));
506 28461 : elem->set_node(0, mesh.node_ptr(i));
507 28461 : elem->set_node(1, mesh.node_ptr(i+1));
508 :
509 28461 : if (i == 0)
510 2253 : boundary_info.add_side(elem, 0, 0);
511 :
512 28461 : if (i == (nx-1))
513 2253 : boundary_info.add_side(elem, 1, 1);
514 :
515 : }
516 646 : break;
517 : }
518 :
519 1080 : case EDGE3:
520 : {
521 9144 : for (unsigned int i=0; i<nx; i++)
522 : {
523 5367 : Elem * elem = mesh.add_elem(Elem::build_with_id(EDGE3, i));
524 5367 : elem->set_node(0, mesh.node_ptr(2*i));
525 5367 : elem->set_node(2, mesh.node_ptr(2*i+1));
526 5367 : elem->set_node(1, mesh.node_ptr(2*i+2));
527 :
528 5367 : if (i == 0)
529 3777 : boundary_info.add_side(elem, 0, 0);
530 :
531 5367 : if (i == (nx-1))
532 3777 : boundary_info.add_side(elem, 1, 1);
533 : }
534 1080 : break;
535 : }
536 :
537 244 : case EDGE4:
538 : {
539 2107 : for (unsigned int i=0; i<nx; i++)
540 : {
541 1253 : Elem * elem = mesh.add_elem(Elem::build_with_id(EDGE4, i));
542 1253 : elem->set_node(0, mesh.node_ptr(3*i));
543 1253 : elem->set_node(2, mesh.node_ptr(3*i+1));
544 1253 : elem->set_node(3, mesh.node_ptr(3*i+2));
545 1253 : elem->set_node(1, mesh.node_ptr(3*i+3));
546 :
547 1253 : if (i == 0)
548 854 : boundary_info.add_side(elem, 0, 0);
549 :
550 1253 : if (i == (nx-1))
551 854 : boundary_info.add_side(elem, 1, 1);
552 : }
553 244 : break;
554 : }
555 :
556 0 : default:
557 0 : libmesh_error_msg("ERROR: Unrecognized 1D element type == " << Utility::enum_to_string(type));
558 : }
559 :
560 : // Move the nodes to their final locations.
561 6884 : if (gauss_lobatto_grid)
562 : {
563 0 : GaussLobattoRedistributionFunction func(nx, xmin, xmax);
564 0 : MeshTools::Modification::redistribute(mesh, func);
565 0 : }
566 : else // !gauss_lobatto_grid
567 : {
568 : Threads::parallel_for_each
569 6884 : (mesh.node_stored_range(),
570 65284 : [xmin, xmax](Node * node)
571 : {
572 49838 : (*node)(0) = (*node)(0)*(xmax-xmin) + xmin;
573 15446 : });
574 : }
575 :
576 : // Add sideset names to boundary info
577 6884 : boundary_info.sideset_name(0) = "left";
578 6884 : boundary_info.sideset_name(1) = "right";
579 :
580 : // Add nodeset names to boundary info
581 6884 : boundary_info.nodeset_name(0) = "left";
582 6884 : boundary_info.nodeset_name(1) = "right";
583 :
584 1970 : break;
585 : }
586 :
587 :
588 :
589 :
590 :
591 :
592 :
593 :
594 :
595 :
596 : //---------------------------------------------------------------------
597 : // Build a 2D quadrilateral
598 17615 : case 2:
599 : {
600 5041 : libmesh_assert_not_equal_to (nx, 0);
601 5041 : libmesh_assert_not_equal_to (ny, 0);
602 5041 : libmesh_assert_equal_to (nz, 0);
603 5041 : libmesh_assert_less (xmin, xmax);
604 5041 : libmesh_assert_less (ymin, ymax);
605 :
606 : // Reserve elements. The TRI3 and TRI6 meshes
607 : // have twice as many elements...
608 : switch (type)
609 : {
610 9706 : case INVALID_ELEM:
611 : case QUAD4:
612 : case QUADSHELL4:
613 : case QUAD8:
614 : case QUADSHELL8:
615 : case QUAD9:
616 : case QUADSHELL9:
617 : case QUAD16:
618 : {
619 9706 : mesh.reserve_elem (nx*ny);
620 6925 : break;
621 : }
622 :
623 7825 : case TRI3:
624 : case TRISHELL3:
625 : case TRI6:
626 : case TRI7:
627 : {
628 7825 : mesh.reserve_elem (2*nx*ny);
629 5589 : break;
630 : }
631 :
632 84 : case C0POLYGON:
633 : {
634 84 : mesh.reserve_elem ((nx + 1) * (ny + 1));
635 60 : break;
636 : }
637 :
638 0 : default:
639 0 : libmesh_error_msg("ERROR: Unrecognized 2D element type == " << Utility::enum_to_string(type));
640 : }
641 :
642 :
643 :
644 : // Reserve nodes. The quadratic element types
645 : // need to reserve more nodes than the linear types.
646 : switch (type)
647 : {
648 4558 : case INVALID_ELEM:
649 : case QUAD4:
650 : case QUADSHELL4:
651 : case TRI3:
652 : case TRISHELL3:
653 : {
654 4558 : mesh.reserve_nodes( (nx+1)*(ny+1) );
655 3247 : break;
656 : }
657 :
658 9630 : case QUAD8:
659 : case QUADSHELL8:
660 : case QUAD9:
661 : case QUADSHELL9:
662 : case TRI6:
663 : {
664 9630 : mesh.reserve_nodes( (2*nx+1)*(2*ny+1) );
665 6878 : break;
666 : }
667 :
668 3077 : case TRI7:
669 : {
670 3077 : mesh.reserve_nodes( (2*nx+1)*(2*ny+1) + 2*nx*ny );
671 2199 : break;
672 : }
673 84 : case C0POLYGON:
674 : {
675 84 : mesh.reserve_nodes (4 + 3*nx*ny + 2*nx + 2*ny);
676 60 : break;
677 : }
678 266 : case QUAD16:
679 : {
680 266 : mesh.reserve_nodes( (3*nx+1)*(3*ny+1) );
681 190 : break;
682 : }
683 0 : default:
684 0 : libmesh_error_msg("ERROR: Unrecognized 2D element type == " << Utility::enum_to_string(type));
685 : }
686 :
687 :
688 :
689 : // Build the nodes. Depends on whether you are using a linear
690 : // or quadratic element, and whether you are using a uniform
691 : // grid or the Gauss-Lobatto grid points.
692 5041 : unsigned int node_id = 0;
693 : switch (type)
694 : {
695 1311 : case INVALID_ELEM:
696 : case QUAD4:
697 : case QUADSHELL4:
698 : case TRI3:
699 : case TRISHELL3:
700 : {
701 18710 : for (unsigned int j=0; j<=ny; j++)
702 117868 : for (unsigned int i=0; i<=nx; i++)
703 : {
704 : const Node * const node =
705 146190 : mesh.add_point(Point(static_cast<Real>(i) / static_cast<Real>(nx),
706 103716 : static_cast<Real>(j) / static_cast<Real>(ny),
707 : 0.),
708 92709 : node_id++);
709 103716 : if (j == 0)
710 13596 : boundary_info.add_node(node, 0);
711 103716 : if (j == ny)
712 13596 : boundary_info.add_node(node, 2);
713 103716 : if (i == 0)
714 14152 : boundary_info.add_node(node, 3);
715 103716 : if (i == nx)
716 14152 : boundary_info.add_node(node, 1);
717 : }
718 :
719 1311 : break;
720 : }
721 :
722 3630 : case QUAD8:
723 : case QUADSHELL8:
724 : case QUAD9:
725 : case QUADSHELL9:
726 : case TRI6:
727 : case TRI7:
728 : {
729 69334 : for (unsigned int j=0; j<=(2*ny); j++)
730 679670 : for (unsigned int i=0; i<=(2*nx); i++)
731 : {
732 : const Node * const node =
733 901226 : mesh.add_point(Point(static_cast<Real>(i) / static_cast<Real>(2 * nx),
734 623043 : static_cast<Real>(j) / static_cast<Real>(2 * ny),
735 : 0),
736 538426 : node_id++);
737 623043 : if (j == 0)
738 57939 : boundary_info.add_node(node, 0);
739 623043 : if (j == 2*ny)
740 57939 : boundary_info.add_node(node, 2);
741 623043 : if (i == 0)
742 56627 : boundary_info.add_node(node, 3);
743 623043 : if (i == 2*nx)
744 56627 : boundary_info.add_node(node, 1);
745 : }
746 :
747 : // We'll add any interior Tri7 nodes last, to keep from
748 : // messing with our idx function
749 12707 : if (type == TRI7)
750 7634 : for (unsigned int j=0; j<(3*ny); j += 3)
751 25890 : for (unsigned int i=0; i<(3*nx); i += 3)
752 : {
753 : // The bottom-right triangle's center node
754 31190 : mesh.add_point(Point(static_cast<Real>(i+2) / static_cast<Real>(3 * nx),
755 21333 : static_cast<Real>(j+1) / static_cast<Real>(3 * ny),
756 : 0),
757 18464 : node_id++);
758 : // The top-left triangle's center node
759 21333 : mesh.add_point(Point(static_cast<Real>(i+1) / static_cast<Real>(3 * nx),
760 21333 : static_cast<Real>(j+2) / static_cast<Real>(3 * ny),
761 : 0),
762 18464 : node_id++);
763 : }
764 :
765 3630 : break;
766 : }
767 :
768 76 : case QUAD16:
769 : {
770 1834 : for (unsigned int j=0; j<=(3*ny); j++)
771 11368 : for (unsigned int i=0; i<=(3*nx); i++)
772 : {
773 : const Node * const node =
774 14000 : mesh.add_point(Point(static_cast<Real>(i) / static_cast<Real>(3 * nx),
775 9800 : static_cast<Real>(j) / static_cast<Real>(3 * ny),
776 : 0),
777 8400 : node_id++);
778 9800 : if (j == 0)
779 1568 : boundary_info.add_node(node, 0);
780 9800 : if (j == 3*ny)
781 1568 : boundary_info.add_node(node, 2);
782 9800 : if (i == 0)
783 1568 : boundary_info.add_node(node, 3);
784 9800 : if (i == 3*nx)
785 1568 : boundary_info.add_node(node, 1);
786 : }
787 76 : break;
788 : }
789 :
790 :
791 24 : case C0POLYGON:
792 : {
793 : // we create the nodes at the same time as the elements
794 24 : break;
795 : }
796 :
797 0 : default:
798 0 : libmesh_error_msg("ERROR: Unrecognized 2D element type == " << Utility::enum_to_string(type));
799 : }
800 :
801 :
802 :
803 :
804 :
805 :
806 : // Build the elements. Each one is a bit different.
807 5041 : unsigned int elem_id = 0;
808 : switch (type)
809 : {
810 :
811 847 : case INVALID_ELEM:
812 : case QUAD4:
813 : case QUADSHELL4:
814 : {
815 10234 : for (unsigned int j=0; j<ny; j++)
816 83416 : for (unsigned int i=0; i<nx; i++)
817 : {
818 77751 : Elem * elem = mesh.add_elem(Elem::build_with_id(type == INVALID_ELEM ? QUAD4 : type, elem_id++));
819 76117 : elem->set_node(0, mesh.node_ptr(idx(type,nx,i,j) ));
820 76117 : elem->set_node(1, mesh.node_ptr(idx(type,nx,i+1,j) ));
821 76117 : elem->set_node(2, mesh.node_ptr(idx(type,nx,i+1,j+1)));
822 76117 : elem->set_node(3, mesh.node_ptr(idx(type,nx,i,j+1) ));
823 :
824 76117 : if (j == 0)
825 6729 : boundary_info.add_side(elem, 0, 0);
826 :
827 76117 : if (j == (ny-1))
828 6729 : boundary_info.add_side(elem, 2, 2);
829 :
830 76117 : if (i == 0)
831 7299 : boundary_info.add_side(elem, 3, 3);
832 :
833 76117 : if (i == (nx-1))
834 7299 : boundary_info.add_side(elem, 1, 1);
835 : }
836 847 : break;
837 : }
838 :
839 :
840 464 : case TRI3:
841 : case TRISHELL3:
842 : {
843 3918 : for (unsigned int j=0; j<ny; j++)
844 6704 : for (unsigned int i=0; i<nx; i++)
845 : {
846 : // Add first Tri3
847 4409 : Elem * elem = mesh.add_elem(Elem::build_with_id(type, elem_id++));
848 4409 : elem->set_node(0, mesh.node_ptr(idx(type,nx,i,j) ));
849 4409 : elem->set_node(1, mesh.node_ptr(idx(type,nx,i+1,j) ));
850 4409 : elem->set_node(2, mesh.node_ptr(idx(type,nx,i+1,j+1)));
851 :
852 4409 : if (j == 0)
853 2309 : boundary_info.add_side(elem, 0, 0);
854 :
855 4409 : if (i == (nx-1))
856 2295 : boundary_info.add_side(elem, 1, 1);
857 :
858 : // Add second Tri3
859 4409 : elem = mesh.add_elem(Elem::build_with_id(type, elem_id++));
860 4409 : elem->set_node(0, mesh.node_ptr(idx(type,nx,i,j) ));
861 4409 : elem->set_node(1, mesh.node_ptr(idx(type,nx,i+1,j+1)));
862 4409 : elem->set_node(2, mesh.node_ptr(idx(type,nx,i,j+1) ));
863 :
864 4409 : if (j == (ny-1))
865 2309 : boundary_info.add_side(elem, 1, 2);
866 :
867 4409 : if (i == 0)
868 2295 : boundary_info.add_side(elem, 2, 3);
869 : }
870 464 : break;
871 : }
872 :
873 :
874 :
875 1858 : case QUAD8:
876 : case QUADSHELL8:
877 : case QUAD9:
878 : case QUADSHELL9:
879 : {
880 18744 : for (unsigned int j=0; j<(2*ny); j += 2)
881 93815 : for (unsigned int i=0; i<(2*nx); i += 2)
882 : {
883 81576 : Elem * elem = mesh.add_elem(Elem::build_with_id(type, elem_id++));
884 81576 : elem->set_node(0, mesh.node_ptr(idx(type,nx,i,j) ));
885 81576 : elem->set_node(1, mesh.node_ptr(idx(type,nx,i+2,j) ));
886 81576 : elem->set_node(2, mesh.node_ptr(idx(type,nx,i+2,j+2)));
887 81576 : elem->set_node(3, mesh.node_ptr(idx(type,nx,i,j+2) ));
888 81576 : elem->set_node(4, mesh.node_ptr(idx(type,nx,i+1,j) ));
889 81576 : elem->set_node(5, mesh.node_ptr(idx(type,nx,i+2,j+1)));
890 81576 : elem->set_node(6, mesh.node_ptr(idx(type,nx,i+1,j+2)));
891 81576 : elem->set_node(7, mesh.node_ptr(idx(type,nx,i,j+1) ));
892 :
893 81576 : if (type == QUAD9 || type == QUADSHELL9)
894 63792 : elem->set_node(8, mesh.node_ptr(idx(type,nx,i+1,j+1)));
895 :
896 81576 : if (j == 0)
897 12792 : boundary_info.add_side(elem, 0, 0);
898 :
899 81576 : if (j == 2*(ny-1))
900 12792 : boundary_info.add_side(elem, 2, 2);
901 :
902 81576 : if (i == 0)
903 12239 : boundary_info.add_side(elem, 3, 3);
904 :
905 81576 : if (i == 2*(nx-1))
906 12239 : boundary_info.add_side(elem, 1, 1);
907 : }
908 1858 : break;
909 : }
910 :
911 :
912 1772 : case TRI6:
913 : case TRI7:
914 : {
915 15923 : for (unsigned int j=0; j<(2*ny); j += 2)
916 58441 : for (unsigned int i=0; i<(2*nx); i += 2)
917 : {
918 : // Add first Tri in the bottom-right of its quad
919 48720 : Elem * elem = mesh.add_elem(Elem::build_with_id(type, elem_id++));
920 48720 : elem->set_node(0, mesh.node_ptr(idx(type,nx,i,j) ));
921 48720 : elem->set_node(1, mesh.node_ptr(idx(type,nx,i+2,j) ));
922 48720 : elem->set_node(2, mesh.node_ptr(idx(type,nx,i+2,j+2)));
923 48720 : elem->set_node(3, mesh.node_ptr(idx(type,nx,i+1,j) ));
924 48720 : elem->set_node(4, mesh.node_ptr(idx(type,nx,i+2,j+1)));
925 48720 : elem->set_node(5, mesh.node_ptr(idx(type,nx,i+1,j+1)));
926 :
927 48720 : if (type == TRI7)
928 21333 : elem->set_node(6, mesh.node_ptr(elem->id()+(2*nx+1)*(2*ny+1)));
929 :
930 48720 : if (j == 0)
931 9824 : boundary_info.add_side(elem, 0, 0);
932 :
933 48720 : if (i == 2*(nx-1))
934 9721 : boundary_info.add_side(elem, 1, 1);
935 :
936 : // Add second Tri in the top left of its quad
937 48720 : elem = mesh.add_elem(Elem::build_with_id(type, elem_id++));
938 48720 : elem->set_node(0, mesh.node_ptr(idx(type,nx,i,j) ));
939 48720 : elem->set_node(1, mesh.node_ptr(idx(type,nx,i+2,j+2)));
940 48720 : elem->set_node(2, mesh.node_ptr(idx(type,nx,i,j+2) ));
941 48720 : elem->set_node(3, mesh.node_ptr(idx(type,nx,i+1,j+1)));
942 48720 : elem->set_node(4, mesh.node_ptr(idx(type,nx,i+1,j+2)));
943 48720 : elem->set_node(5, mesh.node_ptr(idx(type,nx,i,j+1) ));
944 :
945 48720 : if (type == TRI7)
946 21333 : elem->set_node(6, mesh.node_ptr(elem->id()+(2*nx+1)*(2*ny+1)));
947 :
948 48720 : if (j == 2*(ny-1))
949 9824 : boundary_info.add_side(elem, 1, 2);
950 :
951 48720 : if (i == 0)
952 9721 : boundary_info.add_side(elem, 2, 3);
953 : }
954 1772 : break;
955 : };
956 :
957 :
958 76 : case QUAD16:
959 : {
960 700 : for (unsigned int j=0; j<(3*ny); j += 3)
961 1204 : for (unsigned int i=0; i<(3*nx); i +=3)
962 : {
963 770 : Elem * elem = mesh.add_elem(Elem::build_with_id(type, elem_id++));
964 770 : elem->set_node(0, mesh.node_ptr(idx(type,nx,i,j) ));
965 770 : elem->set_node(1, mesh.node_ptr(idx(type,nx,i+3,j) ));
966 770 : elem->set_node(2, mesh.node_ptr(idx(type,nx,i+3,j+3)));
967 770 : elem->set_node(3, mesh.node_ptr(idx(type,nx,i,j+3) ));
968 770 : elem->set_node(4, mesh.node_ptr(idx(type,nx,i+1,j) ));
969 770 : elem->set_node(5, mesh.node_ptr(idx(type,nx,i+2,j)));
970 770 : elem->set_node(6, mesh.node_ptr(idx(type,nx,i+3,j+1)));
971 770 : elem->set_node(7, mesh.node_ptr(idx(type,nx,i+3,j+2)));
972 770 : elem->set_node(8, mesh.node_ptr(idx(type,nx,i+2,j+3)));
973 770 : elem->set_node(9, mesh.node_ptr(idx(type,nx,i+1,j+3)));
974 770 : elem->set_node(10, mesh.node_ptr(idx(type,nx,i,j+2)));
975 770 : elem->set_node(11, mesh.node_ptr(idx(type,nx,i,j+1)));
976 770 : elem->set_node(12, mesh.node_ptr(idx(type,nx,i+1,j+1)));
977 770 : elem->set_node(13, mesh.node_ptr(idx(type,nx,i+2,j+1)));
978 770 : elem->set_node(14, mesh.node_ptr(idx(type,nx,i+2,j+2)));
979 770 : elem->set_node(15, mesh.node_ptr(idx(type,nx,i+1,j+2)));
980 : }
981 76 : break;
982 : };
983 :
984 :
985 24 : case C0POLYGON:
986 : {
987 : // Build a 2D paving using hexagons (center), quads (part of y-boundary)
988 : // and triangles (x-boundaries).
989 : // Vector to re-use previously created nodes
990 48 : std::vector<Node *> node_list;
991 :
992 : // Start with a layer of triangles on the boundary
993 84 : const auto dx_tri = Real(1) / nx;
994 84 : const auto dy_tri = Real(1) / (ny + 1);
995 60 : std::unique_ptr<Elem> new_elem;
996 686 : for (const auto i : make_range(nx + 1))
997 : {
998 : // Make new nodes for bottom layer of triangles
999 : Node *node0, *node1, *node2;
1000 602 : if (i == 0)
1001 : {
1002 108 : node0 = mesh.add_point(Point(0., 0, 0.));
1003 108 : node1 = mesh.add_point(Point(0., dy_tri / 2., 0.));
1004 108 : node2 = mesh.add_point(Point(dx_tri / 2., 0., 0.));
1005 84 : node_list.push_back(node0);
1006 84 : node_list.push_back(node1);
1007 84 : node_list.push_back(node2);
1008 : }
1009 518 : else if (i < nx)
1010 : {
1011 434 : node0 = node_list.back();
1012 558 : node1 = mesh.add_point(Point((i)*dx_tri, dy_tri / 2., 0.));
1013 558 : node2 = mesh.add_point(Point((i + 1. / 2.) * dx_tri, 0., 0.));
1014 434 : node_list.push_back(node1);
1015 434 : node_list.push_back(node2);
1016 : }
1017 : else
1018 : {
1019 84 : node0 = node_list.back();
1020 108 : node1 = mesh.add_point(Point((i)*dx_tri, dy_tri / 2., 0.));
1021 108 : node2 = mesh.add_point(Point((i)*dx_tri, 0., 0.));
1022 84 : node_list.push_back(node1);
1023 84 : node_list.push_back(node2);
1024 : }
1025 :
1026 602 : new_elem = std::make_unique<C0Polygon>(3);
1027 : // Switch to Tri3 when exodus default output supports element type mixes
1028 602 : new_elem->set_node(0, node0);
1029 602 : new_elem->set_node(1, node1);
1030 602 : new_elem->set_node(2, node2);
1031 774 : auto * elem = mesh.add_elem(std::move(new_elem));
1032 :
1033 : // Set boundaries
1034 602 : if (i == 0)
1035 84 : boundary_info.add_side(elem, 0, 3); // left
1036 518 : else if (i == nx)
1037 84 : boundary_info.add_side(elem, 1, 1); // right
1038 602 : boundary_info.add_side(elem, 2, 0); // bottom
1039 : }
1040 : // Start with the second node to build hexagons
1041 24 : unsigned int running_index = 1;
1042 :
1043 : // Build layers of hexagons
1044 24 : const auto hex_side =
1045 84 : (Real(1) - (ny == 1 ?
1046 : dy_tri :
1047 84 : (Real(1) + (ny - 1) / 2.) * dy_tri)) / ny;
1048 602 : for (const auto j : make_range(ny))
1049 : {
1050 4851 : for (const auto i : make_range(nx + (j % 2)))
1051 : {
1052 4333 : if ((j % 2 == 0) || ((i > 0) && (i < nx)))
1053 : {
1054 : Node *n0, *n1, *n2, *n3, *n4, *n5;
1055 3843 : n0 = node_list[running_index++];
1056 3843 : n1 = node_list[running_index++];
1057 3843 : n2 = node_list[running_index];
1058 :
1059 3843 : if (i == 0)
1060 : {
1061 351 : n3 = mesh.add_point(Point(*n0) + RealVectorValue(0, hex_side, 0));
1062 273 : node_list.push_back(n3);
1063 : }
1064 : else
1065 3570 : n3 = node_list.back();
1066 :
1067 4941 : n4 = mesh.add_point(Point(*n1) + RealVectorValue(0, hex_side + dy_tri, 0));
1068 4941 : n5 = mesh.add_point(Point(*n2) + RealVectorValue(0, hex_side, 0));
1069 3843 : node_list.push_back(n4);
1070 3843 : node_list.push_back(n5);
1071 :
1072 3843 : new_elem = std::make_unique<libMesh::C0Polygon>(6);
1073 3843 : new_elem->set_node(0, n0);
1074 3843 : new_elem->set_node(1, n1);
1075 3843 : new_elem->set_node(2, n2);
1076 3843 : new_elem->set_node(3, n5);
1077 3843 : new_elem->set_node(4, n4);
1078 3843 : new_elem->set_node(5, n3);
1079 4941 : auto * elem = mesh.add_elem(std::move(new_elem));
1080 :
1081 : // Set boundaries
1082 3843 : if (i == 0)
1083 273 : boundary_info.add_side(elem, 5, 3); // left
1084 3570 : else if (i == nx)
1085 2196 : boundary_info.add_side(elem, 2, 1); // right
1086 1647 : }
1087 : // The hexagons are offset, so we build on a quad on each external side to fill
1088 490 : else if (i == 0 || i == nx)
1089 : {
1090 : Node *n0, *n1, *n2, *n3;
1091 490 : n0 = node_list[running_index++];
1092 490 : n1 = node_list[running_index];
1093 :
1094 490 : if (i == 0)
1095 : {
1096 315 : n2 = mesh.add_point(Point(*n0) + RealVectorValue(0, hex_side + dy_tri, 0));
1097 245 : node_list.push_back(n2);
1098 315 : n3 = mesh.add_point(Point(*n1) + RealVectorValue(0, hex_side, 0));
1099 : }
1100 : else
1101 : {
1102 245 : n2 = node_list.back();
1103 315 : n3 = mesh.add_point(Point(*n1) + RealVectorValue(0, hex_side + dy_tri, 0));
1104 : }
1105 490 : node_list.push_back(n3);
1106 :
1107 490 : new_elem = std::make_unique<C0Polygon>(4);
1108 : // Switch to Quad4 when exodus default output supports element type mixes
1109 490 : new_elem->set_node(0, n0);
1110 490 : new_elem->set_node(1, n1);
1111 490 : new_elem->set_node(3, n2);
1112 490 : new_elem->set_node(2, n3);
1113 630 : auto * elem = mesh.add_elem(std::move(new_elem));
1114 :
1115 : // Set boundaries
1116 490 : if (i == 0)
1117 245 : boundary_info.add_side(elem, 3, 3); // left
1118 245 : else if (i == nx)
1119 385 : boundary_info.add_side(elem, 1, 1); // right
1120 : }
1121 : else
1122 0 : libmesh_assert(false);
1123 : }
1124 : // Increment once to switch to next 'row' of nodes
1125 518 : running_index++;
1126 :
1127 : // Skip lower right corner node
1128 518 : if (j == 0)
1129 84 : running_index++;
1130 : }
1131 :
1132 : // Build a final layer of triangles
1133 84 : const bool ny_odd = (ny % 2 == 1);
1134 630 : for (const auto i : make_range(nx + ny_odd))
1135 : {
1136 : // Use existing nodes, except at the corners
1137 : Node *node0, *node1, *node2;
1138 546 : if (i == 0 && ny_odd)
1139 : {
1140 36 : node0 = mesh.add_point(Point(0., 1., 0.));
1141 28 : node1 = node_list[running_index++];
1142 36 : node2 = node_list[running_index];
1143 : }
1144 518 : else if (i < nx)
1145 : {
1146 490 : node0 = node_list[running_index++];
1147 490 : node1 = node_list[running_index++];
1148 630 : node2 = node_list[running_index];
1149 : }
1150 : // This case only reached if ny is odd and we are using a triangle in top right corner
1151 : else
1152 : {
1153 28 : node0 = node_list[running_index++];
1154 28 : node1 = node_list[running_index];
1155 36 : node2 = mesh.add_point(Point(1., 1., 0.));
1156 : }
1157 :
1158 546 : new_elem = std::make_unique<C0Polygon>(3);
1159 : // Switch to Tri3 when exodus default output supports element type mixes
1160 546 : new_elem->set_node(0, node0);
1161 546 : new_elem->set_node(1, node1);
1162 546 : new_elem->set_node(2, node2);
1163 702 : auto * elem = mesh.add_elem(std::move(new_elem));
1164 :
1165 : // Set boundaries
1166 546 : if (i == 0)
1167 84 : boundary_info.add_side(elem, 0, 3); // left
1168 462 : else if (i == nx)
1169 28 : boundary_info.add_side(elem, 1, 1); // right
1170 546 : boundary_info.add_side(elem, 2, 2); // top
1171 :
1172 : }
1173 24 : break;
1174 36 : }
1175 :
1176 :
1177 0 : default:
1178 0 : libmesh_error_msg("ERROR: Unrecognized 2D element type == " << Utility::enum_to_string(type));
1179 : }
1180 :
1181 :
1182 :
1183 :
1184 : // Scale the nodal positions
1185 17615 : if (gauss_lobatto_grid)
1186 : {
1187 : GaussLobattoRedistributionFunction func(nx, xmin, xmax,
1188 0 : ny, ymin, ymax);
1189 0 : MeshTools::Modification::redistribute(mesh, func);
1190 0 : }
1191 : else // !gauss_lobatto_grid
1192 : {
1193 : Threads::parallel_for_each
1194 17615 : (mesh.node_stored_range(),
1195 1556431 : [xmin, xmax, ymin, ymax](Node * node)
1196 : {
1197 1009458 : (*node)(0) = (*node)(0)*(xmax-xmin) + xmin;
1198 789263 : (*node)(1) = ((*node)(1))*(ymax-ymin) + ymin;
1199 569068 : });
1200 : }
1201 :
1202 : // Add sideset names to boundary info
1203 17615 : boundary_info.sideset_name(0) = "bottom";
1204 17615 : boundary_info.sideset_name(1) = "right";
1205 17615 : boundary_info.sideset_name(2) = "top";
1206 17615 : boundary_info.sideset_name(3) = "left";
1207 :
1208 : // Add nodeset names to boundary info
1209 17615 : boundary_info.nodeset_name(0) = "bottom";
1210 17615 : boundary_info.nodeset_name(1) = "right";
1211 17615 : boundary_info.nodeset_name(2) = "top";
1212 17615 : boundary_info.nodeset_name(3) = "left";
1213 :
1214 5041 : break;
1215 : }
1216 :
1217 :
1218 :
1219 :
1220 :
1221 :
1222 :
1223 :
1224 :
1225 :
1226 :
1227 : //---------------------------------------------------------------------
1228 : // Build a 3D mesh using hexes, tets, prisms, or pyramids.
1229 20624 : case 3:
1230 : {
1231 5902 : libmesh_assert_not_equal_to (nx, 0);
1232 5902 : libmesh_assert_not_equal_to (ny, 0);
1233 5902 : libmesh_assert_not_equal_to (nz, 0);
1234 5902 : libmesh_assert_less (xmin, xmax);
1235 5902 : libmesh_assert_less (ymin, ymax);
1236 5902 : libmesh_assert_less (zmin, zmax);
1237 :
1238 :
1239 : // Reserve elements. Meshes with prismatic elements require
1240 : // twice as many elements.
1241 : switch (type)
1242 : {
1243 13271 : case INVALID_ELEM:
1244 : case HEX8:
1245 : case HEX20:
1246 : case HEX27:
1247 : case C0POLYHEDRON:
1248 : case TET4: // TET4's are created from an initial HEX27 discretization
1249 : case TET10: // TET10's are created from an initial HEX27 discretization
1250 : case TET14: // TET14's are created from an initial HEX27 discretization
1251 : case PYRAMID5: // PYRAMIDs are created from an initial HEX27 discretization
1252 : case PYRAMID13:
1253 : case PYRAMID14:
1254 : case PYRAMID18:
1255 : {
1256 13271 : mesh.reserve_elem(nx*ny*nz);
1257 9471 : break;
1258 : }
1259 :
1260 7353 : case PRISM6:
1261 : case PRISM15:
1262 : case PRISM18:
1263 : case PRISM20:
1264 : case PRISM21:
1265 : {
1266 7353 : mesh.reserve_elem(2*nx*ny*nz);
1267 5251 : break;
1268 : }
1269 :
1270 0 : default:
1271 0 : libmesh_error_msg("ERROR: Unrecognized 3D element type == " << Utility::enum_to_string(type));
1272 : }
1273 :
1274 :
1275 :
1276 :
1277 :
1278 : // Reserve nodes. Quadratic elements need twice as many nodes as linear elements.
1279 : switch (type)
1280 : {
1281 3599 : case INVALID_ELEM:
1282 : case HEX8:
1283 : case PRISM6:
1284 : case C0POLYHEDRON:
1285 : {
1286 : const dof_id_type grid_nodes =
1287 3599 : cast_int<dof_id_type>((nx+1)*(ny+1)*(nz+1));
1288 :
1289 : // Reserve one interior node per polyhedron for the robust
1290 : // fallback tetrahedralization used when the preferred
1291 : // tetrahedralization cannot be constructed.
1292 : const dof_id_type mid_polyhedron_nodes =
1293 3599 : (type == C0POLYHEDRON) ?
1294 35 : cast_int<dof_id_type>(nx*ny*nz) : 0;
1295 :
1296 3599 : mesh.reserve_nodes(grid_nodes + mid_polyhedron_nodes);
1297 2561 : break;
1298 : }
1299 :
1300 11918 : case HEX20:
1301 : case HEX27:
1302 : case TET4: // TET4's are created from an initial HEX27 discretization
1303 : case TET10: // TET10's are created from an initial HEX27 discretization
1304 : case PYRAMID5: // PYRAMIDs are created from an initial HEX27 discretization
1305 : case PYRAMID13:
1306 : case PYRAMID14:
1307 : case PYRAMID18:
1308 : case PRISM15:
1309 : case PRISM18:
1310 : {
1311 : // FYI: The resulting TET4 mesh will have exactly
1312 : // 5*(nx*ny*nz) + 2*(nx*ny + nx*nz + ny*nz) + (nx+ny+nz) + 1
1313 : // nodes once the additional mid-edge nodes for the HEX27 discretization
1314 : // have been deleted.
1315 11918 : mesh.reserve_nodes( (2*nx+1)*(2*ny+1)*(2*nz+1) );
1316 8512 : break;
1317 : }
1318 :
1319 1719 : case TET14:
1320 : {
1321 4169 : mesh.reserve_nodes( (2*nx+1)*(2*ny+1)*(2*nz+1) +
1322 1719 : 24*nx*ny*nz +
1323 1719 : 4*(nx*ny + ny*nz + nx*nz) );
1324 1229 : break;
1325 : }
1326 :
1327 1526 : case PRISM20:
1328 : {
1329 2834 : mesh.reserve_nodes( (2*nx+1)*(2*ny+1)*(2*nz+1) +
1330 1526 : 2*nx*ny*(nz+1) );
1331 1090 : break;
1332 : }
1333 :
1334 1862 : case PRISM21:
1335 : {
1336 3458 : mesh.reserve_nodes( (2*nx+1)*(2*ny+1)*(2*nz+1) +
1337 1862 : 2*nx*ny*(2*nz+1) );
1338 1330 : break;
1339 : }
1340 :
1341 0 : default:
1342 0 : libmesh_error_msg("ERROR: Unrecognized 3D element type == " << Utility::enum_to_string(type));
1343 : }
1344 :
1345 :
1346 :
1347 :
1348 : // Build the nodes.
1349 5902 : unsigned int node_id = 0;
1350 : switch (type)
1351 : {
1352 1038 : case INVALID_ELEM:
1353 : case HEX8:
1354 : case PRISM6:
1355 : case C0POLYHEDRON:
1356 : {
1357 12501 : for (unsigned int k=0; k<=nz; k++)
1358 36334 : for (unsigned int j=0; j<=ny; j++)
1359 204082 : for (unsigned int i=0; i<=nx; i++)
1360 : {
1361 : const Node * const node =
1362 249788 : mesh.add_point(Point(static_cast<Real>(i) / static_cast<Real>(nx),
1363 176650 : static_cast<Real>(j) / static_cast<Real>(ny),
1364 176650 : static_cast<Real>(k) / static_cast<Real>(nz)),
1365 154794 : node_id++);
1366 176650 : if (k == 0)
1367 36266 : boundary_info.add_node(node, 0);
1368 176650 : if (k == nz)
1369 36266 : boundary_info.add_node(node, 5);
1370 176650 : if (j == 0)
1371 31646 : boundary_info.add_node(node, 1);
1372 176650 : if (j == ny)
1373 31646 : boundary_info.add_node(node, 3);
1374 176650 : if (i == 0)
1375 27432 : boundary_info.add_node(node, 4);
1376 176650 : if (i == nx)
1377 27432 : boundary_info.add_node(node, 2);
1378 : }
1379 :
1380 1038 : break;
1381 : }
1382 :
1383 4864 : case HEX20:
1384 : case HEX27:
1385 : case TET4: // TET4's are created from an initial HEX27 discretization
1386 : case TET10: // TET10's are created from an initial HEX27 discretization
1387 : case TET14: // TET14's are created from an initial HEX27 discretization
1388 : case PYRAMID5: // PYRAMIDs are created from an initial HEX27 discretization
1389 : case PYRAMID13:
1390 : case PYRAMID14:
1391 : case PYRAMID18:
1392 : case PRISM15:
1393 : case PRISM18:
1394 : case PRISM20:
1395 : case PRISM21:
1396 : {
1397 78698 : for (unsigned int k=0; k<=(2*nz); k++)
1398 318424 : for (unsigned int j=0; j<=(2*ny); j++)
1399 1895110 : for (unsigned int i=0; i<=(2*nx); i++)
1400 : {
1401 : const Node * const node =
1402 2376886 : mesh.add_point(Point(static_cast<Real>(i) / static_cast<Real>(2 * nx),
1403 1638359 : static_cast<Real>(j) / static_cast<Real>(2 * ny),
1404 1638359 : static_cast<Real>(k) / static_cast<Real>(2 * nz)),
1405 1413926 : node_id++);
1406 1638359 : if (k == 0)
1407 268075 : boundary_info.add_node(node, 0);
1408 1638359 : if (k == 2*nz)
1409 268075 : boundary_info.add_node(node, 5);
1410 1638359 : if (j == 0)
1411 262605 : boundary_info.add_node(node, 1);
1412 1638359 : if (j == 2*ny)
1413 262605 : boundary_info.add_node(node, 3);
1414 1638359 : if (i == 0)
1415 256751 : boundary_info.add_node(node, 4);
1416 1638359 : if (i == 2*nx)
1417 256751 : boundary_info.add_node(node, 2);
1418 : }
1419 :
1420 17025 : if (type == PRISM20 ||
1421 : type == PRISM21)
1422 : {
1423 3388 : const unsigned int kmax = (type == PRISM20) ? nz : 2*nz;
1424 13363 : for (unsigned int k=0; k<=kmax; k++)
1425 23506 : for (unsigned int j=0; j<ny; j++)
1426 34174 : for (unsigned int i=0; i<nx; i++)
1427 : {
1428 : const Node * const node1 =
1429 29490 : mesh.add_point(Point((static_cast<Real>(i)+1/Real(3)) / static_cast<Real>(nx),
1430 20643 : (static_cast<Real>(j)+1/Real(3)) / static_cast<Real>(ny),
1431 20643 : static_cast<Real>(k) / static_cast<Real>(kmax)),
1432 17694 : node_id++);
1433 20643 : if (k == 0)
1434 6034 : boundary_info.add_node(node1, 0);
1435 20643 : if (k == kmax)
1436 6034 : boundary_info.add_node(node1, 5);
1437 :
1438 : const Node * const node2 =
1439 29490 : mesh.add_point(Point((static_cast<Real>(i)+2/Real(3)) / static_cast<Real>(nx),
1440 20643 : (static_cast<Real>(j)+2/Real(3)) / static_cast<Real>(ny),
1441 5898 : static_cast<Real>(k) / static_cast<Real>(kmax)),
1442 17694 : node_id++);
1443 20643 : if (k == 0)
1444 6034 : boundary_info.add_node(node2, 0);
1445 20643 : if (k == kmax)
1446 6034 : boundary_info.add_node(node2, 5);
1447 : }
1448 : }
1449 :
1450 4864 : break;
1451 : }
1452 :
1453 :
1454 0 : default:
1455 0 : libmesh_error_msg("ERROR: Unrecognized 3D element type == " << Utility::enum_to_string(type));
1456 : }
1457 :
1458 :
1459 :
1460 :
1461 : // Build the elements.
1462 5902 : unsigned int elem_id = 0;
1463 : switch (type)
1464 : {
1465 694 : case INVALID_ELEM:
1466 : case HEX8:
1467 : {
1468 6144 : for (unsigned int k=0; k<nz; k++)
1469 14484 : for (unsigned int j=0; j<ny; j++)
1470 111949 : for (unsigned int i=0; i<nx; i++)
1471 : {
1472 101214 : Elem * elem = mesh.add_elem(Elem::build_with_id(HEX8, elem_id++));
1473 101214 : elem->set_node(0, mesh.node_ptr(idx(type,nx,ny,i,j,k) ));
1474 101214 : elem->set_node(1, mesh.node_ptr(idx(type,nx,ny,i+1,j,k) ));
1475 101214 : elem->set_node(2, mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k) ));
1476 101214 : elem->set_node(3, mesh.node_ptr(idx(type,nx,ny,i,j+1,k) ));
1477 101214 : elem->set_node(4, mesh.node_ptr(idx(type,nx,ny,i,j,k+1) ));
1478 101214 : elem->set_node(5, mesh.node_ptr(idx(type,nx,ny,i+1,j,k+1) ));
1479 101214 : elem->set_node(6, mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k+1)));
1480 101214 : elem->set_node(7, mesh.node_ptr(idx(type,nx,ny,i,j+1,k+1) ));
1481 :
1482 101214 : if (k == 0)
1483 18582 : boundary_info.add_side(elem, 0, 0);
1484 :
1485 101214 : if (k == (nz-1))
1486 18582 : boundary_info.add_side(elem, 5, 5);
1487 :
1488 101214 : if (j == 0)
1489 14102 : boundary_info.add_side(elem, 1, 1);
1490 :
1491 101214 : if (j == (ny-1))
1492 14102 : boundary_info.add_side(elem, 3, 3);
1493 :
1494 101214 : if (i == 0)
1495 10735 : boundary_info.add_side(elem, 4, 4);
1496 :
1497 101214 : if (i == (nx-1))
1498 10735 : boundary_info.add_side(elem, 2, 2);
1499 : }
1500 694 : break;
1501 : }
1502 :
1503 :
1504 35 : case C0POLYHEDRON:
1505 : {
1506 35 : const std::array<std::array<unsigned int, 4>, 6> side_nodes =
1507 : {{{0, 1, 2, 3}, // min z
1508 : {0, 1, 5, 4}, // min y
1509 : {2, 6, 5, 1}, // max x
1510 : {2, 3, 7, 6}, // max y
1511 : {0, 4, 7, 3}, // min x
1512 : {5, 6, 7, 4}}}; // max z
1513 :
1514 105 : for (unsigned int k=0; k<nz; k++)
1515 210 : for (unsigned int j=0; j<ny; j++)
1516 420 : for (unsigned int i=0; i<nx; i++)
1517 : {
1518 : std::array<Node *, 8> elem_nodes =
1519 280 : {{mesh.node_ptr(idx(type,nx,ny,i,j,k) ),
1520 280 : mesh.node_ptr(idx(type,nx,ny,i+1,j,k) ),
1521 280 : mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k) ),
1522 280 : mesh.node_ptr(idx(type,nx,ny,i,j+1,k) ),
1523 280 : mesh.node_ptr(idx(type,nx,ny,i,j,k+1) ),
1524 280 : mesh.node_ptr(idx(type,nx,ny,i+1,j,k+1) ),
1525 280 : mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k+1)),
1526 1960 : mesh.node_ptr(idx(type,nx,ny,i,j+1,k+1) )}};
1527 :
1528 440 : std::vector<std::shared_ptr<Polygon>> sides(side_nodes.size());
1529 1960 : for (auto s : index_range(side_nodes))
1530 : {
1531 2160 : sides[s] = std::make_shared<C0Polygon>(side_nodes[s].size());
1532 8400 : for (auto n : index_range(side_nodes[s]))
1533 10560 : sides[s]->set_node(n, elem_nodes[side_nodes[s][n]]);
1534 : }
1535 :
1536 280 : std::unique_ptr<Node> mid_elem_node;
1537 : std::unique_ptr<Elem> new_elem =
1538 360 : std::make_unique<C0Polyhedron>(sides, mid_elem_node);
1539 280 : if (mid_elem_node)
1540 0 : mesh.add_node(std::move(mid_elem_node));
1541 :
1542 280 : new_elem->set_id() = elem_id++;
1543 360 : Elem * elem = mesh.add_elem(std::move(new_elem));
1544 :
1545 280 : if (k == 0)
1546 140 : boundary_info.add_side(elem, 0, 0);
1547 :
1548 280 : if (k == (nz-1))
1549 140 : boundary_info.add_side(elem, 5, 5);
1550 :
1551 280 : if (j == 0)
1552 140 : boundary_info.add_side(elem, 1, 1);
1553 :
1554 280 : if (j == (ny-1))
1555 140 : boundary_info.add_side(elem, 3, 3);
1556 :
1557 280 : if (i == 0)
1558 140 : boundary_info.add_side(elem, 4, 4);
1559 :
1560 280 : if (i == (nx-1))
1561 140 : boundary_info.add_side(elem, 2, 2);
1562 120 : }
1563 10 : break;
1564 : }
1565 :
1566 :
1567 :
1568 :
1569 334 : case PRISM6:
1570 : {
1571 2653 : for (unsigned int k=0; k<nz; k++)
1572 3696 : for (unsigned int j=0; j<ny; j++)
1573 6258 : for (unsigned int i=0; i<nx; i++)
1574 : {
1575 : // First Prism
1576 4046 : Elem * elem = mesh.add_elem(Elem::build_with_id(PRISM6, elem_id++));
1577 4046 : elem->set_node(0, mesh.node_ptr(idx(type,nx,ny,i,j,k) ));
1578 4046 : elem->set_node(1, mesh.node_ptr(idx(type,nx,ny,i+1,j,k) ));
1579 4046 : elem->set_node(2, mesh.node_ptr(idx(type,nx,ny,i,j+1,k) ));
1580 4046 : elem->set_node(3, mesh.node_ptr(idx(type,nx,ny,i,j,k+1) ));
1581 4046 : elem->set_node(4, mesh.node_ptr(idx(type,nx,ny,i+1,j,k+1) ));
1582 4046 : elem->set_node(5, mesh.node_ptr(idx(type,nx,ny,i,j+1,k+1) ));
1583 :
1584 : // Add sides for first prism to boundary info object
1585 4046 : if (i==0)
1586 2212 : boundary_info.add_side(elem, 3, 4);
1587 :
1588 4046 : if (j==0)
1589 2212 : boundary_info.add_side(elem, 1, 1);
1590 :
1591 4046 : if (k==0)
1592 2212 : boundary_info.add_side(elem, 0, 0);
1593 :
1594 4046 : if (k == (nz-1))
1595 2212 : boundary_info.add_side(elem, 4, 5);
1596 :
1597 : // Second Prism
1598 4046 : elem = mesh.add_elem(Elem::build_with_id(PRISM6, elem_id++));
1599 4046 : elem->set_node(0, mesh.node_ptr(idx(type,nx,ny,i+1,j,k) ));
1600 4046 : elem->set_node(1, mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k) ));
1601 4046 : elem->set_node(2, mesh.node_ptr(idx(type,nx,ny,i,j+1,k) ));
1602 4046 : elem->set_node(3, mesh.node_ptr(idx(type,nx,ny,i+1,j,k+1) ));
1603 4046 : elem->set_node(4, mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k+1)));
1604 4046 : elem->set_node(5, mesh.node_ptr(idx(type,nx,ny,i,j+1,k+1) ));
1605 :
1606 : // Add sides for second prism to boundary info object
1607 4046 : if (i == (nx-1))
1608 2212 : boundary_info.add_side(elem, 1, 2);
1609 :
1610 4046 : if (j == (ny-1))
1611 2212 : boundary_info.add_side(elem, 2, 3);
1612 :
1613 4046 : if (k==0)
1614 2212 : boundary_info.add_side(elem, 0, 0);
1615 :
1616 4046 : if (k == (nz-1))
1617 2212 : boundary_info.add_side(elem, 4, 5);
1618 : }
1619 334 : break;
1620 : }
1621 :
1622 :
1623 :
1624 :
1625 :
1626 :
1627 3096 : case HEX20:
1628 : case HEX27:
1629 : case TET4: // TET4's are created from an initial HEX27 discretization
1630 : case TET10: // TET10's are created from an initial HEX27 discretization
1631 : case TET14: // TET14's are created from an initial HEX27 discretization
1632 : case PYRAMID5: // PYRAMIDs are created from an initial HEX27 discretization
1633 : case PYRAMID13:
1634 : case PYRAMID14:
1635 : case PYRAMID18:
1636 : {
1637 25559 : for (unsigned int k=0; k<(2*nz); k += 2)
1638 41817 : for (unsigned int j=0; j<(2*ny); j += 2)
1639 138156 : for (unsigned int i=0; i<(2*nx); i += 2)
1640 : {
1641 111057 : ElemType build_type = (type == HEX20) ? HEX20 : HEX27;
1642 111057 : Elem * elem = mesh.add_elem(Elem::build_with_id(build_type, elem_id++));
1643 :
1644 111057 : elem->set_node(0, mesh.node_ptr(idx(type,nx,ny,i, j, k) ));
1645 111057 : elem->set_node(1, mesh.node_ptr(idx(type,nx,ny,i+2,j, k) ));
1646 111057 : elem->set_node(2, mesh.node_ptr(idx(type,nx,ny,i+2,j+2,k) ));
1647 111057 : elem->set_node(3, mesh.node_ptr(idx(type,nx,ny,i, j+2,k) ));
1648 111057 : elem->set_node(4, mesh.node_ptr(idx(type,nx,ny,i, j, k+2)));
1649 111057 : elem->set_node(5, mesh.node_ptr(idx(type,nx,ny,i+2,j, k+2)));
1650 111057 : elem->set_node(6, mesh.node_ptr(idx(type,nx,ny,i+2,j+2,k+2)));
1651 111057 : elem->set_node(7, mesh.node_ptr(idx(type,nx,ny,i, j+2,k+2)));
1652 111057 : elem->set_node(8, mesh.node_ptr(idx(type,nx,ny,i+1,j, k) ));
1653 111057 : elem->set_node(9, mesh.node_ptr(idx(type,nx,ny,i+2,j+1,k) ));
1654 111057 : elem->set_node(10, mesh.node_ptr(idx(type,nx,ny,i+1,j+2,k) ));
1655 111057 : elem->set_node(11, mesh.node_ptr(idx(type,nx,ny,i, j+1,k) ));
1656 111057 : elem->set_node(12, mesh.node_ptr(idx(type,nx,ny,i, j, k+1)));
1657 111057 : elem->set_node(13, mesh.node_ptr(idx(type,nx,ny,i+2,j, k+1)));
1658 111057 : elem->set_node(14, mesh.node_ptr(idx(type,nx,ny,i+2,j+2,k+1)));
1659 111057 : elem->set_node(15, mesh.node_ptr(idx(type,nx,ny,i, j+2,k+1)));
1660 111057 : elem->set_node(16, mesh.node_ptr(idx(type,nx,ny,i+1,j, k+2)));
1661 111057 : elem->set_node(17, mesh.node_ptr(idx(type,nx,ny,i+2,j+1,k+2)));
1662 111057 : elem->set_node(18, mesh.node_ptr(idx(type,nx,ny,i+1,j+2,k+2)));
1663 111057 : elem->set_node(19, mesh.node_ptr(idx(type,nx,ny,i, j+1,k+2)));
1664 :
1665 111057 : if ((type == HEX27) || (type == TET4) || (type == TET10) || (type == TET14) ||
1666 7014 : (type == PYRAMID5) || (type == PYRAMID13) || (type == PYRAMID14) ||
1667 2480 : (type == PYRAMID18))
1668 : {
1669 106395 : elem->set_node(20, mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k) ));
1670 106395 : elem->set_node(21, mesh.node_ptr(idx(type,nx,ny,i+1,j, k+1)));
1671 106395 : elem->set_node(22, mesh.node_ptr(idx(type,nx,ny,i+2,j+1,k+1)));
1672 106395 : elem->set_node(23, mesh.node_ptr(idx(type,nx,ny,i+1,j+2,k+1)));
1673 106395 : elem->set_node(24, mesh.node_ptr(idx(type,nx,ny,i, j+1,k+1)));
1674 106395 : elem->set_node(25, mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k+2)));
1675 106395 : elem->set_node(26, mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k+1)));
1676 : }
1677 :
1678 111057 : if (k == 0)
1679 29639 : boundary_info.add_side(elem, 0, 0);
1680 :
1681 111057 : if (k == 2*(nz-1))
1682 29639 : boundary_info.add_side(elem, 5, 5);
1683 :
1684 111057 : if (j == 0)
1685 28340 : boundary_info.add_side(elem, 1, 1);
1686 :
1687 111057 : if (j == 2*(ny-1))
1688 28340 : boundary_info.add_side(elem, 3, 3);
1689 :
1690 111057 : if (i == 0)
1691 27099 : boundary_info.add_side(elem, 4, 4);
1692 :
1693 111057 : if (i == 2*(nx-1))
1694 27099 : boundary_info.add_side(elem, 2, 2);
1695 : }
1696 3096 : break;
1697 : }
1698 :
1699 :
1700 :
1701 :
1702 1768 : case PRISM15:
1703 : case PRISM18:
1704 : case PRISM20:
1705 : case PRISM21:
1706 : {
1707 13790 : for (unsigned int k=0; k<(2*nz); k += 2)
1708 18096 : for (unsigned int j=0; j<(2*ny); j += 2)
1709 26928 : for (unsigned int i=0; i<(2*nx); i += 2)
1710 : {
1711 : // First Prism
1712 16438 : Elem * elem = mesh.add_elem(Elem::build_with_id(type, elem_id++));
1713 16438 : elem->set_node(0, mesh.node_ptr(idx(type,nx,ny,i, j, k) ));
1714 16438 : elem->set_node(1, mesh.node_ptr(idx(type,nx,ny,i+2,j, k) ));
1715 16438 : elem->set_node(2, mesh.node_ptr(idx(type,nx,ny,i, j+2,k) ));
1716 16438 : elem->set_node(3, mesh.node_ptr(idx(type,nx,ny,i, j, k+2)));
1717 16438 : elem->set_node(4, mesh.node_ptr(idx(type,nx,ny,i+2,j, k+2)));
1718 16438 : elem->set_node(5, mesh.node_ptr(idx(type,nx,ny,i, j+2,k+2)));
1719 16438 : elem->set_node(6, mesh.node_ptr(idx(type,nx,ny,i+1,j, k) ));
1720 16438 : elem->set_node(7, mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k) ));
1721 16438 : elem->set_node(8, mesh.node_ptr(idx(type,nx,ny,i, j+1,k) ));
1722 16438 : elem->set_node(9, mesh.node_ptr(idx(type,nx,ny,i, j, k+1)));
1723 16438 : elem->set_node(10, mesh.node_ptr(idx(type,nx,ny,i+2,j, k+1)));
1724 16438 : elem->set_node(11, mesh.node_ptr(idx(type,nx,ny,i, j+2,k+1)));
1725 16438 : elem->set_node(12, mesh.node_ptr(idx(type,nx,ny,i+1,j, k+2)));
1726 16438 : elem->set_node(13, mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k+2)));
1727 16438 : elem->set_node(14, mesh.node_ptr(idx(type,nx,ny,i, j+1,k+2)));
1728 :
1729 21182 : if (type == PRISM18 ||
1730 14036 : type == PRISM20 ||
1731 : type == PRISM21)
1732 : {
1733 13288 : elem->set_node(15, mesh.node_ptr(idx(type,nx,ny,i+1,j, k+1)));
1734 13288 : elem->set_node(16, mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k+1)));
1735 13288 : elem->set_node(17, mesh.node_ptr(idx(type,nx,ny,i, j+1,k+1)));
1736 : }
1737 :
1738 16438 : if (type == PRISM20)
1739 : {
1740 4515 : const dof_id_type base_idx = (2*nx+1)*(2*ny+1)*(2*nz+1);
1741 4515 : elem->set_node(18, mesh.node_ptr(base_idx+((k/2)*(nx*ny)+j/2*nx+i/2)*2));
1742 4515 : elem->set_node(19, mesh.node_ptr(base_idx+(((k/2)+1)*(nx*ny)+j/2*nx+i/2)*2));
1743 : }
1744 :
1745 16438 : if (type == PRISM21)
1746 : {
1747 5047 : const dof_id_type base_idx = (2*nx+1)*(2*ny+1)*(2*nz+1);
1748 5047 : elem->set_node(18, mesh.node_ptr(base_idx+(k*(nx*ny)+j/2*nx+i/2)*2));
1749 5047 : elem->set_node(19, mesh.node_ptr(base_idx+((k+2)*(nx*ny)+j/2*nx+i/2)*2));
1750 5047 : elem->set_node(20, mesh.node_ptr(base_idx+((k+1)*(nx*ny)+j/2*nx+i/2)*2));
1751 : }
1752 :
1753 : // Add sides for first prism to boundary info object
1754 16438 : if (i==0)
1755 10490 : boundary_info.add_side(elem, 3, 4);
1756 :
1757 16438 : if (j==0)
1758 10490 : boundary_info.add_side(elem, 1, 1);
1759 :
1760 16438 : if (k==0)
1761 10540 : boundary_info.add_side(elem, 0, 0);
1762 :
1763 16438 : if (k == 2*(nz-1))
1764 10540 : boundary_info.add_side(elem, 4, 5);
1765 :
1766 :
1767 : // Second Prism
1768 16438 : elem = mesh.add_elem(Elem::build_with_id(type, elem_id++));
1769 16438 : elem->set_node(0, mesh.node_ptr(idx(type,nx,ny,i+2,j,k) ));
1770 16438 : elem->set_node(1, mesh.node_ptr(idx(type,nx,ny,i+2,j+2,k) ));
1771 16438 : elem->set_node(2, mesh.node_ptr(idx(type,nx,ny,i,j+2,k) ));
1772 16438 : elem->set_node(3, mesh.node_ptr(idx(type,nx,ny,i+2,j,k+2) ));
1773 16438 : elem->set_node(4, mesh.node_ptr(idx(type,nx,ny,i+2,j+2,k+2) ));
1774 16438 : elem->set_node(5, mesh.node_ptr(idx(type,nx,ny,i,j+2,k+2) ));
1775 16438 : elem->set_node(6, mesh.node_ptr(idx(type,nx,ny,i+2,j+1,k) ));
1776 16438 : elem->set_node(7, mesh.node_ptr(idx(type,nx,ny,i+1,j+2,k) ));
1777 16438 : elem->set_node(8, mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k) ));
1778 16438 : elem->set_node(9, mesh.node_ptr(idx(type,nx,ny,i+2,j,k+1) ));
1779 16438 : elem->set_node(10, mesh.node_ptr(idx(type,nx,ny,i+2,j+2,k+1)));
1780 16438 : elem->set_node(11, mesh.node_ptr(idx(type,nx,ny,i,j+2,k+1) ));
1781 16438 : elem->set_node(12, mesh.node_ptr(idx(type,nx,ny,i+2,j+1,k+2)));
1782 16438 : elem->set_node(13, mesh.node_ptr(idx(type,nx,ny,i+1,j+2,k+2)));
1783 16438 : elem->set_node(14, mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k+2)));
1784 :
1785 16438 : if (type == PRISM18 ||
1786 8197 : type == PRISM20 ||
1787 : type == PRISM21)
1788 : {
1789 13288 : elem->set_node(15, mesh.node_ptr(idx(type,nx,ny,i+2,j+1,k+1)));
1790 13288 : elem->set_node(16, mesh.node_ptr(idx(type,nx,ny,i+1,j+2,k+1)));
1791 13288 : elem->set_node(17, mesh.node_ptr(idx(type,nx,ny,i+1,j+1,k+1)));
1792 : }
1793 :
1794 16438 : if (type == PRISM20)
1795 : {
1796 4515 : const dof_id_type base_idx = (2*nx+1)*(2*ny+1)*(2*nz+1);
1797 4515 : elem->set_node(18, mesh.node_ptr(base_idx+((k/2)*(nx*ny)+j/2*nx+i/2)*2+1));
1798 4515 : elem->set_node(19, mesh.node_ptr(base_idx+(((k/2)+1)*(nx*ny)+j/2*nx+i/2)*2+1));
1799 : }
1800 :
1801 16438 : if (type == PRISM21)
1802 : {
1803 5047 : const dof_id_type base_idx = (2*nx+1)*(2*ny+1)*(2*nz+1);
1804 5047 : elem->set_node(18, mesh.node_ptr(base_idx+(k*(nx*ny)+j/2*nx+i/2)*2+1));
1805 5047 : elem->set_node(19, mesh.node_ptr(base_idx+((k+2)*(nx*ny)+j/2*nx+i/2)*2+1));
1806 5047 : elem->set_node(20, mesh.node_ptr(base_idx+((k+1)*(nx*ny)+j/2*nx+i/2)*2+1));
1807 : }
1808 :
1809 : // Add sides for second prism to boundary info object
1810 16438 : if (i == 2*(nx-1))
1811 10490 : boundary_info.add_side(elem, 1, 2);
1812 :
1813 16438 : if (j == 2*(ny-1))
1814 10490 : boundary_info.add_side(elem, 2, 3);
1815 :
1816 16438 : if (k==0)
1817 10540 : boundary_info.add_side(elem, 0, 0);
1818 :
1819 16438 : if (k == 2*(nz-1))
1820 10540 : boundary_info.add_side(elem, 4, 5);
1821 :
1822 : }
1823 1768 : break;
1824 : }
1825 :
1826 :
1827 :
1828 :
1829 :
1830 0 : default:
1831 0 : libmesh_error_msg("ERROR: Unrecognized 3D element type == " << Utility::enum_to_string(type));
1832 : }
1833 :
1834 :
1835 :
1836 :
1837 : //.......................................
1838 : // Scale the nodal positions
1839 20624 : if (gauss_lobatto_grid)
1840 : {
1841 : GaussLobattoRedistributionFunction func(nx, xmin, xmax,
1842 : ny, ymin, ymax,
1843 0 : nz, zmin, zmax);
1844 0 : MeshTools::Modification::redistribute(mesh, func);
1845 0 : }
1846 : else // !gauss_lobatto_grid
1847 : {
1848 : Threads::parallel_for_each
1849 20624 : (mesh.node_stored_range(),
1850 5152320 : [xmin, xmax, ymin, ymax, zmin, zmax](Node * node)
1851 : {
1852 2369763 : (*node)(0) = ((*node)(0))*(xmax-xmin) + xmin;
1853 2369763 : (*node)(1) = ((*node)(1))*(ymax-ymin) + ymin;
1854 1856295 : (*node)(2) = ((*node)(2))*(zmax-zmin) + zmin;
1855 1342827 : });
1856 : }
1857 :
1858 :
1859 :
1860 : // Additional work for tets and pyramids: we take the existing
1861 : // HEX27 discretization and split each element into 24
1862 : // sub-tets or 6 sub-pyramids.
1863 : //
1864 : // 24 isn't the minimum-possible number of tets, but it
1865 : // obviates any concerns about the edge orientations between
1866 : // the various elements.
1867 26526 : if ((type == TET4) ||
1868 19888 : (type == TET10) ||
1869 19398 : (type == TET14) ||
1870 16227 : (type == PYRAMID5) ||
1871 4472 : (type == PYRAMID13) ||
1872 19987 : (type == PYRAMID14) ||
1873 11145 : (type == PYRAMID18))
1874 : {
1875 : // Temporary storage for new elements. (24 tets per hex, 6 pyramids)
1876 4962 : std::vector<std::unique_ptr<Elem>> new_elements;
1877 :
1878 : // For avoiding extraneous construction of element sides
1879 5791 : std::unique_ptr<Elem> side;
1880 :
1881 5791 : if ((type == TET4) || (type == TET10) || (type == TET14))
1882 4293 : new_elements.reserve(24*mesh.n_elem());
1883 : else
1884 1498 : new_elements.reserve(6*mesh.n_elem());
1885 :
1886 : // Create tetrahedra or pyramids
1887 49218 : for (auto & base_hex : mesh.element_ptr_range())
1888 : {
1889 : // Get a pointer to the node located at the HEX27 center
1890 27303 : Node * apex_node = base_hex->node_ptr(26);
1891 :
1892 : // Container to catch ids handed back from BoundaryInfo
1893 15316 : std::vector<boundary_id_type> ids;
1894 :
1895 191121 : for (auto s : base_hex->side_index_range())
1896 : {
1897 : // Get the boundary ID(s) for this side
1898 163818 : boundary_info.boundary_ids(base_hex, s, ids);
1899 :
1900 : // We're creating this Mesh, so there should be 0 or 1 boundary IDs.
1901 45948 : libmesh_assert(ids.size() <= 1);
1902 :
1903 : // A convenient name for the side's ID.
1904 163818 : boundary_id_type b_id = ids.empty() ? BoundaryInfo::invalid_id : ids[0];
1905 :
1906 : // Need to build the full-ordered side!
1907 163818 : base_hex->build_side_ptr(side, s);
1908 :
1909 163818 : if ((type == TET4) || (type == TET10) || (type == TET14))
1910 : {
1911 : // Build 4 sub-tets per side
1912 546300 : for (unsigned int sub_tet=0; sub_tet<4; ++sub_tet)
1913 : {
1914 752640 : new_elements.push_back( Elem::build(TET4) );
1915 121440 : auto & sub_elem = new_elements.back();
1916 679920 : sub_elem->set_node(0, side->node_ptr(sub_tet));
1917 679920 : sub_elem->set_node(1, side->node_ptr(8)); // center of the face
1918 558480 : sub_elem->set_node(2, side->node_ptr(sub_tet==3 ? 0 : sub_tet+1 )); // wrap-around
1919 437040 : sub_elem->set_node(3, apex_node); // apex node always used!
1920 :
1921 : // If the original hex was a boundary hex, add the new sub_tet's side
1922 : // 0 with the same b_id. Note: the tets are all aligned so that their
1923 : // side 0 is on the boundary.
1924 437040 : if (b_id != BoundaryInfo::invalid_id)
1925 268472 : boundary_info.add_side(sub_elem.get(), 0, b_id);
1926 30360 : }
1927 : } // end if ((type == TET4) || (type == TET10) || (type == TET14))
1928 :
1929 : else // type==PYRAMID*
1930 : {
1931 : // Build 1 sub-pyramid per side.
1932 93528 : new_elements.push_back( Elem::build(PYRAMID5) );
1933 15588 : auto & sub_elem = new_elements.back();
1934 :
1935 : // Set the base. Note that since the apex is *inside* the base_hex,
1936 : // and the pyramid uses a counter-clockwise base numbering, we need to
1937 : // reverse the [1] and [3] node indices.
1938 85734 : sub_elem->set_node(0, side->node_ptr(0));
1939 85734 : sub_elem->set_node(1, side->node_ptr(3));
1940 85734 : sub_elem->set_node(2, side->node_ptr(2));
1941 85734 : sub_elem->set_node(3, side->node_ptr(1));
1942 :
1943 : // Set the apex
1944 54558 : sub_elem->set_node(4, apex_node);
1945 :
1946 : // If the original hex was a boundary hex, add the new sub_pyr's side
1947 : // 4 (the square base) with the same b_id.
1948 54558 : if (b_id != BoundaryInfo::invalid_id)
1949 35370 : boundary_info.add_side(sub_elem.get(), 4, b_id);
1950 : } // end else type==PYRAMID*
1951 : }
1952 2483 : }
1953 :
1954 :
1955 : // Delete the original HEX27 elements from the mesh, and the boundary info structure.
1956 49218 : for (auto & elem : mesh.element_ptr_range())
1957 : {
1958 27303 : boundary_info.remove(elem); // Safe even if elem has no boundary info.
1959 27303 : mesh.delete_elem(elem);
1960 2483 : }
1961 :
1962 : // Add the new elements
1963 497389 : for (auto i : index_range(new_elements))
1964 : {
1965 479598 : new_elements[i]->set_id(i);
1966 765654 : mesh.add_elem( std::move(new_elements[i]) );
1967 : }
1968 :
1969 2483 : } // end if (type == TET*,PYRAMID*)
1970 :
1971 :
1972 : // Use all_second_order to convert the TET4's to TET10's or PYRAMID5's to PYRAMID14's
1973 20624 : if ((type == TET10) || (type == PYRAMID14))
1974 1671 : mesh.all_second_order();
1975 :
1976 18953 : else if (type == PYRAMID13)
1977 350 : mesh.all_second_order(/*full_ordered=*/false);
1978 :
1979 18603 : else if ((type == TET14) || (type == PYRAMID18))
1980 2146 : mesh.all_complete_order();
1981 :
1982 :
1983 : // Add sideset names to boundary info (Z axis out of the screen)
1984 20624 : boundary_info.sideset_name(0) = "back";
1985 20624 : boundary_info.sideset_name(1) = "bottom";
1986 20624 : boundary_info.sideset_name(2) = "right";
1987 20624 : boundary_info.sideset_name(3) = "top";
1988 20624 : boundary_info.sideset_name(4) = "left";
1989 20624 : boundary_info.sideset_name(5) = "front";
1990 :
1991 : // Add nodeset names to boundary info
1992 20624 : boundary_info.nodeset_name(0) = "back";
1993 20624 : boundary_info.nodeset_name(1) = "bottom";
1994 20624 : boundary_info.nodeset_name(2) = "right";
1995 20624 : boundary_info.nodeset_name(3) = "top";
1996 20624 : boundary_info.nodeset_name(4) = "left";
1997 20624 : boundary_info.nodeset_name(5) = "front";
1998 :
1999 5902 : break;
2000 : } // end case dim==3
2001 :
2002 0 : default:
2003 0 : libmesh_error_msg("Unknown dimension " << mesh.mesh_dimension());
2004 : }
2005 :
2006 : // Done building the mesh. Now prepare it for use.
2007 45414 : mesh.prepare_for_use ();
2008 45414 : }
2009 :
2010 :
2011 :
2012 116 : void MeshTools::Generation::build_point (UnstructuredMesh & mesh,
2013 : const ElemType type,
2014 : const bool gauss_lobatto_grid)
2015 : {
2016 : // This method only makes sense in 0D!
2017 : // But we now just turn a non-0D mesh into a 0D mesh
2018 : //libmesh_assert_equal_to (mesh.mesh_dimension(), 1);
2019 :
2020 116 : build_cube(mesh,
2021 : 0, 0, 0,
2022 : 0., 0.,
2023 : 0., 0.,
2024 : 0., 0.,
2025 : type,
2026 : gauss_lobatto_grid);
2027 116 : }
2028 :
2029 :
2030 690 : void MeshTools::Generation::build_line (UnstructuredMesh & mesh,
2031 : const unsigned int nx,
2032 : const Real xmin, const Real xmax,
2033 : const ElemType type,
2034 : const bool gauss_lobatto_grid)
2035 : {
2036 : // This method only makes sense in 1D!
2037 : // But we now just turn a non-1D mesh into a 1D mesh
2038 : //libmesh_assert_equal_to (mesh.mesh_dimension(), 1);
2039 :
2040 690 : build_cube(mesh,
2041 : nx, 0, 0,
2042 : xmin, xmax,
2043 : 0., 0.,
2044 : 0., 0.,
2045 : type,
2046 : gauss_lobatto_grid);
2047 690 : }
2048 :
2049 :
2050 :
2051 2461 : void MeshTools::Generation::build_square (UnstructuredMesh & mesh,
2052 : const unsigned int nx,
2053 : const unsigned int ny,
2054 : const Real xmin, const Real xmax,
2055 : const Real ymin, const Real ymax,
2056 : const ElemType type,
2057 : const bool gauss_lobatto_grid)
2058 : {
2059 : // This method only makes sense in 2D!
2060 : // But we now just turn a non-2D mesh into a 2D mesh
2061 : //libmesh_assert_equal_to (mesh.mesh_dimension(), 2);
2062 :
2063 : // Call the build_cube() member to actually do the work for us.
2064 2461 : build_cube (mesh,
2065 : nx, ny, 0,
2066 : xmin, xmax,
2067 : ymin, ymax,
2068 : 0., 0.,
2069 : type,
2070 : gauss_lobatto_grid);
2071 2461 : }
2072 :
2073 :
2074 :
2075 :
2076 :
2077 :
2078 :
2079 :
2080 :
2081 : #ifndef LIBMESH_ENABLE_AMR
2082 : void MeshTools::Generation::build_sphere (UnstructuredMesh &,
2083 : const Real,
2084 : const unsigned int,
2085 : const ElemType,
2086 : const unsigned int,
2087 : const bool)
2088 : {
2089 : libmesh_error_msg("Building a circle/sphere only works with AMR.");
2090 : }
2091 :
2092 : #else
2093 :
2094 233 : void MeshTools::Generation::build_sphere (UnstructuredMesh & mesh,
2095 : const Real rad,
2096 : const unsigned int nr,
2097 : const ElemType type,
2098 : const unsigned int n_smooth,
2099 : const bool flat)
2100 : {
2101 68 : libmesh_assert_greater (rad, 0.);
2102 : //libmesh_assert_greater (nr, 0); // must refine at least once otherwise will end up with a square/cube
2103 :
2104 204 : LOG_SCOPE("build_sphere()", "MeshTools::Generation");
2105 :
2106 : // Clear the mesh and start from scratch, but save the original
2107 : // mesh_dimension, since the original intent of this function was to
2108 : // allow the geometric entity (line, circle, ball, sphere)
2109 : // constructed to be determined by the mesh's dimension.
2110 : unsigned char orig_mesh_dimension =
2111 233 : cast_int<unsigned char>(mesh.mesh_dimension());
2112 233 : mesh.clear();
2113 233 : mesh.set_mesh_dimension(orig_mesh_dimension);
2114 :
2115 : // If mesh.mesh_dimension()==1, it *could* be because the user
2116 : // constructed a Mesh without specifying a dimension (since this is
2117 : // allowed now) and hence it got the default dimension of 1. In
2118 : // this case, we will try to infer the dimension they *really*
2119 : // wanted from the requested ElemType, and if they don't match, go
2120 : // with the ElemType.
2121 233 : if (mesh.mesh_dimension() == 1)
2122 : {
2123 233 : switch (type)
2124 : {
2125 89 : case HEX8:
2126 : case HEX27:
2127 : case TET4:
2128 : case TET10:
2129 : case TET14:
2130 89 : mesh.set_mesh_dimension(3);
2131 26 : break;
2132 116 : case TRI3:
2133 : case TRI6:
2134 : case TRI7:
2135 : case QUAD4:
2136 : case QUADSHELL4:
2137 : case QUAD8:
2138 : case QUADSHELL8:
2139 : case QUAD9:
2140 : case QUADSHELL9:
2141 : case QUAD16:
2142 116 : mesh.set_mesh_dimension(2);
2143 34 : break;
2144 28 : case EDGE2:
2145 : case EDGE3:
2146 : case EDGE4:
2147 28 : mesh.set_mesh_dimension(1);
2148 8 : break;
2149 0 : case INVALID_ELEM:
2150 : // Just keep the existing dimension
2151 0 : break;
2152 0 : default:
2153 0 : libmesh_error_msg("build_sphere(): Please specify a mesh dimension or a valid ElemType (EDGE{2,3,4}, TRI{3,6,7}, QUAD{4,8,9}, HEX{8,27}, TET{4,10,14})");
2154 : }
2155 : }
2156 :
2157 68 : BoundaryInfo & boundary_info = mesh.get_boundary_info();
2158 :
2159 : // Building while distributed is a little more complicated
2160 233 : const bool is_replicated = mesh.is_replicated();
2161 :
2162 : // Sphere is centered at origin by default
2163 68 : const Point cent;
2164 :
2165 466 : const Sphere sphere (cent, rad);
2166 :
2167 233 : switch (mesh.mesh_dimension())
2168 : {
2169 : //-----------------------------------------------------------------
2170 : // Build a line in one dimension
2171 28 : case 1:
2172 : {
2173 28 : build_line (mesh, 3, -rad, rad, type);
2174 :
2175 8 : break;
2176 : }
2177 :
2178 :
2179 :
2180 :
2181 : //-----------------------------------------------------------------
2182 : // Build a circle or hollow sphere in two dimensions
2183 116 : case 2:
2184 : {
2185 : // For DistributedMesh, if we don't specify node IDs the Mesh
2186 : // will try to pick an appropriate (unique) one for us. But
2187 : // since we are adding these nodes on all processors, we want
2188 : // to be sure they have consistent IDs across all processors.
2189 34 : unsigned node_id = 0;
2190 :
2191 116 : if (flat)
2192 : {
2193 34 : const Real sqrt_2 = std::sqrt(2.);
2194 116 : const Real rad_2 = .25*rad;
2195 116 : const Real rad_sqrt_2 = rad/sqrt_2;
2196 :
2197 : // (Temporary) convenient storage for node pointers
2198 150 : std::vector<Node *> nodes(8);
2199 :
2200 : // Point 0
2201 150 : nodes[0] = mesh.add_point (Point(-rad_2,-rad_2, 0.), node_id++);
2202 :
2203 : // Point 1
2204 150 : nodes[1] = mesh.add_point (Point( rad_2,-rad_2, 0.), node_id++);
2205 :
2206 : // Point 2
2207 150 : nodes[2] = mesh.add_point (Point( rad_2, rad_2, 0.), node_id++);
2208 :
2209 : // Point 3
2210 150 : nodes[3] = mesh.add_point (Point(-rad_2, rad_2, 0.), node_id++);
2211 :
2212 : // Point 4
2213 150 : nodes[4] = mesh.add_point (Point(-rad_sqrt_2,-rad_sqrt_2, 0.), node_id++);
2214 :
2215 : // Point 5
2216 150 : nodes[5] = mesh.add_point (Point( rad_sqrt_2,-rad_sqrt_2, 0.), node_id++);
2217 :
2218 : // Point 6
2219 150 : nodes[6] = mesh.add_point (Point( rad_sqrt_2, rad_sqrt_2, 0.), node_id++);
2220 :
2221 : // Point 7
2222 150 : nodes[7] = mesh.add_point (Point(-rad_sqrt_2, rad_sqrt_2, 0.), node_id++);
2223 :
2224 : // Build the elements & set node pointers
2225 :
2226 : // Element 0
2227 : {
2228 116 : Elem * elem0 = mesh.add_elem (Elem::build(QUAD4));
2229 116 : elem0->set_node(0, nodes[0]);
2230 116 : elem0->set_node(1, nodes[1]);
2231 116 : elem0->set_node(2, nodes[2]);
2232 116 : elem0->set_node(3, nodes[3]);
2233 : }
2234 :
2235 : // Element 1
2236 : {
2237 116 : Elem * elem1 = mesh.add_elem (Elem::build(QUAD4));
2238 116 : elem1->set_node(0, nodes[4]);
2239 116 : elem1->set_node(1, nodes[0]);
2240 116 : elem1->set_node(2, nodes[3]);
2241 116 : elem1->set_node(3, nodes[7]);
2242 : }
2243 :
2244 : // Element 2
2245 : {
2246 116 : Elem * elem2 = mesh.add_elem (Elem::build(QUAD4));
2247 116 : elem2->set_node(0, nodes[4]);
2248 116 : elem2->set_node(1, nodes[5]);
2249 116 : elem2->set_node(2, nodes[1]);
2250 116 : elem2->set_node(3, nodes[0]);
2251 : }
2252 :
2253 : // Element 3
2254 : {
2255 116 : Elem * elem3 = mesh.add_elem (Elem::build(QUAD4));
2256 116 : elem3->set_node(0, nodes[1]);
2257 116 : elem3->set_node(1, nodes[5]);
2258 116 : elem3->set_node(2, nodes[6]);
2259 116 : elem3->set_node(3, nodes[2]);
2260 : }
2261 :
2262 : // Element 4
2263 : {
2264 116 : Elem * elem4 = mesh.add_elem (Elem::build(QUAD4));
2265 116 : elem4->set_node(0, nodes[3]);
2266 116 : elem4->set_node(1, nodes[2]);
2267 116 : elem4->set_node(2, nodes[6]);
2268 116 : elem4->set_node(3, nodes[7]);
2269 : }
2270 :
2271 : }
2272 : else
2273 : {
2274 : // Create the 12 vertices of a regular unit icosahedron
2275 0 : Real t = 0.5 * (1 + std::sqrt(5.0));
2276 0 : Real s = rad / std::sqrt(1 + t*t);
2277 0 : t *= s;
2278 :
2279 0 : mesh.add_point (Point(-s, t, 0), node_id++);
2280 0 : mesh.add_point (Point( s, t, 0), node_id++);
2281 0 : mesh.add_point (Point(-s, -t, 0), node_id++);
2282 0 : mesh.add_point (Point( s, -t, 0), node_id++);
2283 :
2284 0 : mesh.add_point (Point( 0, -s, t), node_id++);
2285 0 : mesh.add_point (Point( 0, s, t), node_id++);
2286 0 : mesh.add_point (Point( 0, -s, -t), node_id++);
2287 0 : mesh.add_point (Point( 0, s, -t), node_id++);
2288 :
2289 0 : mesh.add_point (Point( t, 0, -s), node_id++);
2290 0 : mesh.add_point (Point( t, 0, s), node_id++);
2291 0 : mesh.add_point (Point(-t, 0, -s), node_id++);
2292 0 : mesh.add_point (Point(-t, 0, s), node_id++);
2293 :
2294 : // Create the 20 triangles of the icosahedron
2295 : static const unsigned int idx1 [6] = {11, 5, 1, 7, 10, 11};
2296 : static const unsigned int idx2 [6] = {9, 4, 2, 6, 8, 9};
2297 : static const unsigned int idx3 [6] = {1, 5, 11, 10, 7, 1};
2298 :
2299 0 : for (unsigned int i = 0; i < 5; ++i)
2300 : {
2301 : // 5 elems around point 0
2302 0 : Elem * new_elem = mesh.add_elem(Elem::build(TRI3));
2303 0 : new_elem->set_node(0, mesh.node_ptr(0));
2304 0 : new_elem->set_node(1, mesh.node_ptr(idx1[i]));
2305 0 : new_elem->set_node(2, mesh.node_ptr(idx1[i+1]));
2306 :
2307 : // 5 adjacent elems
2308 0 : new_elem = mesh.add_elem(Elem::build(TRI3));
2309 0 : new_elem->set_node(0, mesh.node_ptr(idx3[i]));
2310 0 : new_elem->set_node(1, mesh.node_ptr(idx3[i+1]));
2311 0 : new_elem->set_node(2, mesh.node_ptr(idx2[i]));
2312 :
2313 : // 5 elems around point 3
2314 0 : new_elem = mesh.add_elem(Elem::build(TRI3));
2315 0 : new_elem->set_node(0, mesh.node_ptr(3));
2316 0 : new_elem->set_node(1, mesh.node_ptr(idx2[i]));
2317 0 : new_elem->set_node(2, mesh.node_ptr(idx2[i+1]));
2318 :
2319 : // 5 adjacent elems
2320 0 : new_elem = mesh.add_elem(Elem::build(TRI3));
2321 0 : new_elem->set_node(0, mesh.node_ptr(idx2[i+1]));
2322 0 : new_elem->set_node(1, mesh.node_ptr(idx2[i]));
2323 0 : new_elem->set_node(2, mesh.node_ptr(idx3[i+1]));
2324 : }
2325 : }
2326 :
2327 34 : break;
2328 : } // end case 2
2329 :
2330 :
2331 :
2332 :
2333 :
2334 : //-----------------------------------------------------------------
2335 : // Build a sphere in three dimensions
2336 89 : case 3:
2337 : {
2338 : // (Currently) supported types
2339 89 : if (!((type == HEX8) || (type == HEX27) || (type == TET4) ||
2340 : (type == TET10) || (type == TET14)))
2341 : {
2342 0 : libmesh_error_msg("Error: Only HEX8/27 and TET4/10/14 are currently supported in 3D.");
2343 : }
2344 :
2345 :
2346 : // 3D analog of 2D initial grid:
2347 : const Real
2348 89 : r_small = 0.25*rad, // 0.25 *radius
2349 89 : r_med = (0.125*std::sqrt(2.)+0.5)*rad; // .67677*radius
2350 :
2351 : // (Temporary) convenient storage for node pointers
2352 115 : std::vector<Node *> nodes(16);
2353 :
2354 : // For DistributedMesh, if we don't specify node IDs the Mesh
2355 : // will try to pick an appropriate (unique) one for us. But
2356 : // since we are adding these nodes on all processors, we want
2357 : // to be sure they have consistent IDs across all processors.
2358 26 : unsigned node_id = 0;
2359 :
2360 : // Points 0-7 are the initial HEX8
2361 115 : nodes[0] = mesh.add_point (Point(-r_small,-r_small, -r_small), node_id++);
2362 115 : nodes[1] = mesh.add_point (Point( r_small,-r_small, -r_small), node_id++);
2363 115 : nodes[2] = mesh.add_point (Point( r_small, r_small, -r_small), node_id++);
2364 115 : nodes[3] = mesh.add_point (Point(-r_small, r_small, -r_small), node_id++);
2365 115 : nodes[4] = mesh.add_point (Point(-r_small,-r_small, r_small), node_id++);
2366 115 : nodes[5] = mesh.add_point (Point( r_small,-r_small, r_small), node_id++);
2367 115 : nodes[6] = mesh.add_point (Point( r_small, r_small, r_small), node_id++);
2368 115 : nodes[7] = mesh.add_point (Point(-r_small, r_small, r_small), node_id++);
2369 :
2370 : // Points 8-15 are for the outer hexes, we number them in the same way
2371 115 : nodes[8] = mesh.add_point (Point(-r_med,-r_med, -r_med), node_id++);
2372 115 : nodes[9] = mesh.add_point (Point( r_med,-r_med, -r_med), node_id++);
2373 115 : nodes[10] = mesh.add_point (Point( r_med, r_med, -r_med), node_id++);
2374 115 : nodes[11] = mesh.add_point (Point(-r_med, r_med, -r_med), node_id++);
2375 115 : nodes[12] = mesh.add_point (Point(-r_med,-r_med, r_med), node_id++);
2376 115 : nodes[13] = mesh.add_point (Point( r_med,-r_med, r_med), node_id++);
2377 115 : nodes[14] = mesh.add_point (Point( r_med, r_med, r_med), node_id++);
2378 115 : nodes[15] = mesh.add_point (Point(-r_med, r_med, r_med), node_id++);
2379 :
2380 : // Now create the elements and add them to the mesh
2381 : // Element 0 - center element
2382 : {
2383 89 : Elem * elem0 = mesh.add_elem(Elem::build(HEX8));
2384 89 : elem0->set_node(0, nodes[0]);
2385 89 : elem0->set_node(1, nodes[1]);
2386 89 : elem0->set_node(2, nodes[2]);
2387 89 : elem0->set_node(3, nodes[3]);
2388 89 : elem0->set_node(4, nodes[4]);
2389 89 : elem0->set_node(5, nodes[5]);
2390 89 : elem0->set_node(6, nodes[6]);
2391 89 : elem0->set_node(7, nodes[7]);
2392 : }
2393 :
2394 : // Element 1 - "bottom"
2395 : {
2396 89 : Elem * elem1 = mesh.add_elem(Elem::build(HEX8));
2397 89 : elem1->set_node(0, nodes[8]);
2398 89 : elem1->set_node(1, nodes[9]);
2399 89 : elem1->set_node(2, nodes[10]);
2400 89 : elem1->set_node(3, nodes[11]);
2401 89 : elem1->set_node(4, nodes[0]);
2402 89 : elem1->set_node(5, nodes[1]);
2403 89 : elem1->set_node(6, nodes[2]);
2404 89 : elem1->set_node(7, nodes[3]);
2405 : }
2406 :
2407 : // Element 2 - "front"
2408 : {
2409 89 : Elem * elem2 = mesh.add_elem(Elem::build(HEX8));
2410 89 : elem2->set_node(0, nodes[8]);
2411 89 : elem2->set_node(1, nodes[9]);
2412 89 : elem2->set_node(2, nodes[1]);
2413 89 : elem2->set_node(3, nodes[0]);
2414 89 : elem2->set_node(4, nodes[12]);
2415 89 : elem2->set_node(5, nodes[13]);
2416 89 : elem2->set_node(6, nodes[5]);
2417 89 : elem2->set_node(7, nodes[4]);
2418 : }
2419 :
2420 : // Element 3 - "right"
2421 : {
2422 89 : Elem * elem3 = mesh.add_elem(Elem::build(HEX8));
2423 89 : elem3->set_node(0, nodes[1]);
2424 89 : elem3->set_node(1, nodes[9]);
2425 89 : elem3->set_node(2, nodes[10]);
2426 89 : elem3->set_node(3, nodes[2]);
2427 89 : elem3->set_node(4, nodes[5]);
2428 89 : elem3->set_node(5, nodes[13]);
2429 89 : elem3->set_node(6, nodes[14]);
2430 89 : elem3->set_node(7, nodes[6]);
2431 : }
2432 :
2433 : // Element 4 - "back"
2434 : {
2435 89 : Elem * elem4 = mesh.add_elem(Elem::build(HEX8));
2436 89 : elem4->set_node(0, nodes[3]);
2437 89 : elem4->set_node(1, nodes[2]);
2438 89 : elem4->set_node(2, nodes[10]);
2439 89 : elem4->set_node(3, nodes[11]);
2440 89 : elem4->set_node(4, nodes[7]);
2441 89 : elem4->set_node(5, nodes[6]);
2442 89 : elem4->set_node(6, nodes[14]);
2443 89 : elem4->set_node(7, nodes[15]);
2444 : }
2445 :
2446 : // Element 5 - "left"
2447 : {
2448 89 : Elem * elem5 = mesh.add_elem(Elem::build(HEX8));
2449 89 : elem5->set_node(0, nodes[8]);
2450 89 : elem5->set_node(1, nodes[0]);
2451 89 : elem5->set_node(2, nodes[3]);
2452 89 : elem5->set_node(3, nodes[11]);
2453 89 : elem5->set_node(4, nodes[12]);
2454 89 : elem5->set_node(5, nodes[4]);
2455 89 : elem5->set_node(6, nodes[7]);
2456 89 : elem5->set_node(7, nodes[15]);
2457 : }
2458 :
2459 : // Element 6 - "top"
2460 : {
2461 89 : Elem * elem6 = mesh.add_elem(Elem::build(HEX8));
2462 89 : elem6->set_node(0, nodes[4]);
2463 89 : elem6->set_node(1, nodes[5]);
2464 89 : elem6->set_node(2, nodes[6]);
2465 89 : elem6->set_node(3, nodes[7]);
2466 89 : elem6->set_node(4, nodes[12]);
2467 89 : elem6->set_node(5, nodes[13]);
2468 89 : elem6->set_node(6, nodes[14]);
2469 89 : elem6->set_node(7, nodes[15]);
2470 : }
2471 :
2472 26 : break;
2473 : } // end case 3
2474 :
2475 0 : default:
2476 0 : libmesh_error_msg("Unknown dimension " << mesh.mesh_dimension());
2477 :
2478 :
2479 :
2480 : } // end switch (dim)
2481 :
2482 : // Now we have the beginnings of a sphere.
2483 : // Add some more elements by doing uniform refinements and
2484 : // popping nodes to the boundary.
2485 466 : MeshRefinement mesh_refinement (mesh);
2486 :
2487 : // For avoiding extraneous element side construction
2488 233 : std::unique_ptr<Elem> side;
2489 :
2490 : // Loop over the elements, refine, pop nodes to boundary.
2491 562 : for (unsigned int r=0; r<nr; r++)
2492 : {
2493 : // A DistributedMesh needs a little prep before refinement, and
2494 : // may need us to keep track of ghost node movement.
2495 96 : std::unordered_set<dof_id_type> moved_ghost_nodes;
2496 329 : if (!is_replicated)
2497 84 : mesh.prepare_for_use();
2498 :
2499 329 : mesh_refinement.uniformly_refine(1);
2500 :
2501 : const bool move_only_boundary_nodes =
2502 329 : mesh.mesh_dimension() != 2 || flat;
2503 : MeshTools::Modification::interpolate_surface
2504 658 : (mesh, sphere, /*ids=*/{}, move_only_boundary_nodes);
2505 : }
2506 :
2507 : // A DistributedMesh needs a little prep before flattening
2508 233 : if (!is_replicated)
2509 42 : mesh.prepare_for_use();
2510 :
2511 : // The mesh now contains a refinement hierarchy due to the refinements
2512 : // used to generate the grid. In order to call other support functions
2513 : // like all_tri() and all_second_order, you need a "flat" mesh file (with no
2514 : // refinement trees) so
2515 233 : MeshTools::Modification::flatten(mesh);
2516 :
2517 : // Convert all the tensor product elements to simplices if requested
2518 233 : if ((type == TRI7) || (type == TRI6) || (type == TRI3) ||
2519 116 : (type == TET4) || (type == TET10) || (type == TET14))
2520 : {
2521 : // A DistributedMesh needs a little prep before all_tri()
2522 49 : if (is_replicated)
2523 42 : mesh.prepare_for_use();
2524 :
2525 49 : MeshTools::Modification::all_tri(mesh);
2526 : }
2527 :
2528 : // Convert to second-order elements if the user requested it.
2529 301 : if (Elem::build(type)->default_order() != FIRST)
2530 : {
2531 163 : if (type == TET14)
2532 0 : mesh.all_complete_order();
2533 : else
2534 : {
2535 : // type is second-order, determine if it is the
2536 : // "full-ordered" second-order element, or the "serendipity"
2537 : // second order element. Note also that all_second_order
2538 : // can't be called once the mesh has been refined.
2539 163 : bool full_ordered = !((type==QUAD8) || (type==HEX20));
2540 163 : mesh.all_second_order(full_ordered);
2541 : }
2542 :
2543 : // And pop to the boundary again...
2544 25924 : for (const auto & elem : mesh.active_element_ptr_range())
2545 124685 : for (auto s : elem->side_index_range())
2546 131158 : if (elem->neighbor_ptr(s) == nullptr)
2547 : {
2548 4178 : elem->build_side_ptr(side, s);
2549 :
2550 : // Pop each point to the sphere boundary
2551 37044 : for (auto n : side->node_index_range())
2552 42688 : side->point(n) =
2553 42688 : sphere.closest_point(side->point(n));
2554 67 : }
2555 : }
2556 :
2557 :
2558 : // The meshes could probably use some smoothing.
2559 233 : if (mesh.mesh_dimension() > 1)
2560 : {
2561 265 : LaplaceMeshSmoother smoother(mesh, n_smooth);
2562 205 : smoother.smooth();
2563 : }
2564 :
2565 : // We'll give the whole sphere surface a boundary id of 0
2566 91940 : for (const auto & elem : mesh.active_element_ptr_range())
2567 376577 : for (auto s : elem->side_index_range())
2568 378678 : if (!elem->neighbor_ptr(s))
2569 8513 : boundary_info.add_side(elem, s, 0);
2570 :
2571 : // Done building the mesh. Now prepare it for use.
2572 233 : mesh.prepare_for_use();
2573 233 : }
2574 :
2575 : #endif // #ifndef LIBMESH_ENABLE_AMR
2576 :
2577 :
2578 : // Meshes the tensor product of a 1D and a 1D-or-2D domain.
2579 49 : void MeshTools::Generation::build_extrusion (UnstructuredMesh & mesh,
2580 : const MeshBase & cross_section,
2581 : const unsigned int nz,
2582 : RealVectorValue extrusion_vector,
2583 : QueryElemSubdomainIDBase * elem_subdomain)
2584 : {
2585 28 : LOG_SCOPE("build_extrusion()", "MeshTools::Generation");
2586 :
2587 49 : if (!cross_section.n_elem())
2588 0 : return;
2589 :
2590 49 : dof_id_type orig_elem = cross_section.n_elem();
2591 49 : dof_id_type orig_nodes = cross_section.n_nodes();
2592 :
2593 : #ifdef LIBMESH_ENABLE_UNIQUE_ID
2594 49 : unique_id_type orig_unique_ids = cross_section.parallel_max_unique_id();
2595 : #endif
2596 :
2597 49 : unsigned int order = 1;
2598 :
2599 14 : BoundaryInfo & boundary_info = mesh.get_boundary_info();
2600 14 : const BoundaryInfo & cross_section_boundary_info = cross_section.get_boundary_info();
2601 :
2602 : // Copy name maps from old to new boundary. We won't copy the whole
2603 : // BoundaryInfo because that copies bc ids too, and we need to set
2604 : // those more carefully.
2605 14 : boundary_info.set_sideset_name_map() = cross_section_boundary_info.get_sideset_name_map();
2606 14 : boundary_info.set_nodeset_name_map() = cross_section_boundary_info.get_nodeset_name_map();
2607 14 : boundary_info.set_edgeset_name_map() = cross_section_boundary_info.get_edgeset_name_map();
2608 :
2609 : // If cross_section is distributed, so is its extrusion
2610 49 : if (!cross_section.is_serial())
2611 0 : mesh.delete_remote_elements();
2612 :
2613 : // We know a priori how many elements we'll need
2614 49 : mesh.reserve_elem(nz*orig_elem);
2615 :
2616 : // For straightforward meshes we need one or two additional layers per
2617 : // element.
2618 182 : if (cross_section.elements_begin() != cross_section.elements_end() &&
2619 143 : (*cross_section.elements_begin())->default_order() == SECOND)
2620 14 : order = 2;
2621 49 : mesh.comm().max(order);
2622 :
2623 49 : mesh.reserve_nodes((order*nz+1)*orig_nodes);
2624 :
2625 : // Container to catch the boundary IDs handed back by the BoundaryInfo object
2626 28 : std::vector<boundary_id_type> ids_to_copy;
2627 :
2628 1794 : for (const auto & node : cross_section.node_ptr_range())
2629 : {
2630 6510 : for (unsigned int k=0; k != order*nz+1; ++k)
2631 : {
2632 5313 : const dof_id_type new_node_id = node->id() + k * orig_nodes;
2633 5313 : Node * my_node = mesh.query_node_ptr(new_node_id);
2634 5313 : if (!my_node)
2635 : {
2636 : std::unique_ptr<Node> new_node = Node::build
2637 6831 : (*node + (extrusion_vector * k / nz / order),
2638 1518 : new_node_id);
2639 5313 : new_node->processor_id() = node->processor_id();
2640 :
2641 : #ifdef LIBMESH_ENABLE_UNIQUE_ID
2642 : // Let's give the base of the extruded mesh the same
2643 : // unique_ids as the source mesh, in case anyone finds that
2644 : // a useful map to preserve.
2645 5313 : const unique_id_type uid = (k == 0) ?
2646 684 : node->unique_id() :
2647 4116 : orig_unique_ids + (k-1)*(orig_nodes + orig_elem) + node->id();
2648 :
2649 1518 : new_node->set_unique_id(uid);
2650 : #endif
2651 :
2652 5313 : cross_section_boundary_info.boundary_ids(node, ids_to_copy);
2653 5313 : boundary_info.add_node(new_node.get(), ids_to_copy);
2654 :
2655 8349 : mesh.add_node(std::move(new_node));
2656 2277 : }
2657 : }
2658 21 : }
2659 :
2660 : const std::set<boundary_id_type> & side_ids =
2661 14 : cross_section_boundary_info.get_side_boundary_ids();
2662 :
2663 14 : boundary_id_type next_side_id = side_ids.empty() ?
2664 49 : 0 : cast_int<boundary_id_type>(*side_ids.rbegin() + 1);
2665 :
2666 : // side_ids may not include ids from remote elements, in which case
2667 : // some processors may have underestimated the next_side_id; let's
2668 : // fix that.
2669 49 : cross_section.comm().max(next_side_id);
2670 :
2671 734 : for (const auto & elem : cross_section.element_ptr_range())
2672 : {
2673 455 : const ElemType etype = elem->type();
2674 :
2675 : // build_extrusion currently only works on coarse meshes
2676 130 : libmesh_assert (!elem->parent());
2677 :
2678 1421 : for (unsigned int k=0; k != nz; ++k)
2679 : {
2680 690 : std::unique_ptr<Elem> new_elem;
2681 966 : switch (etype)
2682 : {
2683 0 : case EDGE2:
2684 : {
2685 0 : new_elem = Elem::build(QUAD4);
2686 0 : new_elem->set_node(0, mesh.node_ptr(elem->node_ptr(0)->id() + (k * orig_nodes)));
2687 0 : new_elem->set_node(1, mesh.node_ptr(elem->node_ptr(1)->id() + (k * orig_nodes)));
2688 0 : new_elem->set_node(2, mesh.node_ptr(elem->node_ptr(1)->id() + ((k+1) * orig_nodes)));
2689 0 : new_elem->set_node(3, mesh.node_ptr(elem->node_ptr(0)->id() + ((k+1) * orig_nodes)));
2690 :
2691 0 : if (elem->neighbor_ptr(0) == remote_elem)
2692 0 : new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
2693 0 : if (elem->neighbor_ptr(1) == remote_elem)
2694 0 : new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
2695 :
2696 0 : break;
2697 : }
2698 0 : case EDGE3:
2699 : {
2700 0 : new_elem = Elem::build(QUAD9);
2701 0 : new_elem->set_node(0, mesh.node_ptr(elem->node_ptr(0)->id() + (2*k * orig_nodes)));
2702 0 : new_elem->set_node(1, mesh.node_ptr(elem->node_ptr(1)->id() + (2*k * orig_nodes)));
2703 0 : new_elem->set_node(2, mesh.node_ptr(elem->node_ptr(1)->id() + ((2*k+2) * orig_nodes)));
2704 0 : new_elem->set_node(3, mesh.node_ptr(elem->node_ptr(0)->id() + ((2*k+2) * orig_nodes)));
2705 0 : new_elem->set_node(4, mesh.node_ptr(elem->node_ptr(2)->id() + (2*k * orig_nodes)));
2706 0 : new_elem->set_node(5, mesh.node_ptr(elem->node_ptr(1)->id() + ((2*k+1) * orig_nodes)));
2707 0 : new_elem->set_node(6, mesh.node_ptr(elem->node_ptr(2)->id() + ((2*k+2) * orig_nodes)));
2708 0 : new_elem->set_node(7, mesh.node_ptr(elem->node_ptr(0)->id() + ((2*k+1) * orig_nodes)));
2709 0 : new_elem->set_node(8, mesh.node_ptr(elem->node_ptr(2)->id() + ((2*k+1) * orig_nodes)));
2710 :
2711 0 : if (elem->neighbor_ptr(0) == remote_elem)
2712 0 : new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
2713 0 : if (elem->neighbor_ptr(1) == remote_elem)
2714 0 : new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
2715 :
2716 0 : break;
2717 : }
2718 168 : case TRI3:
2719 : {
2720 240 : new_elem = Elem::build(PRISM6);
2721 216 : new_elem->set_node(0, mesh.node_ptr(elem->node_ptr(0)->id() + (k * orig_nodes)));
2722 216 : new_elem->set_node(1, mesh.node_ptr(elem->node_ptr(1)->id() + (k * orig_nodes)));
2723 216 : new_elem->set_node(2, mesh.node_ptr(elem->node_ptr(2)->id() + (k * orig_nodes)));
2724 216 : new_elem->set_node(3, mesh.node_ptr(elem->node_ptr(0)->id() + ((k+1) * orig_nodes)));
2725 216 : new_elem->set_node(4, mesh.node_ptr(elem->node_ptr(1)->id() + ((k+1) * orig_nodes)));
2726 216 : new_elem->set_node(5, mesh.node_ptr(elem->node_ptr(2)->id() + ((k+1) * orig_nodes)));
2727 :
2728 216 : if (elem->neighbor_ptr(0) == remote_elem)
2729 0 : new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
2730 216 : if (elem->neighbor_ptr(1) == remote_elem)
2731 0 : new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
2732 216 : if (elem->neighbor_ptr(2) == remote_elem)
2733 0 : new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
2734 :
2735 48 : break;
2736 : }
2737 0 : case TRI6:
2738 : {
2739 0 : new_elem = Elem::build(PRISM18);
2740 0 : new_elem->set_node(0, mesh.node_ptr(elem->node_ptr(0)->id() + (2*k * orig_nodes)));
2741 0 : new_elem->set_node(1, mesh.node_ptr(elem->node_ptr(1)->id() + (2*k * orig_nodes)));
2742 0 : new_elem->set_node(2, mesh.node_ptr(elem->node_ptr(2)->id() + (2*k * orig_nodes)));
2743 0 : new_elem->set_node(3, mesh.node_ptr(elem->node_ptr(0)->id() + ((2*k+2) * orig_nodes)));
2744 0 : new_elem->set_node(4, mesh.node_ptr(elem->node_ptr(1)->id() + ((2*k+2) * orig_nodes)));
2745 0 : new_elem->set_node(5, mesh.node_ptr(elem->node_ptr(2)->id() + ((2*k+2) * orig_nodes)));
2746 0 : new_elem->set_node(6, mesh.node_ptr(elem->node_ptr(3)->id() + (2*k * orig_nodes)));
2747 0 : new_elem->set_node(7, mesh.node_ptr(elem->node_ptr(4)->id() + (2*k * orig_nodes)));
2748 0 : new_elem->set_node(8, mesh.node_ptr(elem->node_ptr(5)->id() + (2*k * orig_nodes)));
2749 0 : new_elem->set_node(9, mesh.node_ptr(elem->node_ptr(0)->id() + ((2*k+1) * orig_nodes)));
2750 0 : new_elem->set_node(10, mesh.node_ptr(elem->node_ptr(1)->id() + ((2*k+1) * orig_nodes)));
2751 0 : new_elem->set_node(11, mesh.node_ptr(elem->node_ptr(2)->id() + ((2*k+1) * orig_nodes)));
2752 0 : new_elem->set_node(12, mesh.node_ptr(elem->node_ptr(3)->id() + ((2*k+2) * orig_nodes)));
2753 0 : new_elem->set_node(13, mesh.node_ptr(elem->node_ptr(4)->id() + ((2*k+2) * orig_nodes)));
2754 0 : new_elem->set_node(14, mesh.node_ptr(elem->node_ptr(5)->id() + ((2*k+2) * orig_nodes)));
2755 0 : new_elem->set_node(15, mesh.node_ptr(elem->node_ptr(3)->id() + ((2*k+1) * orig_nodes)));
2756 0 : new_elem->set_node(16, mesh.node_ptr(elem->node_ptr(4)->id() + ((2*k+1) * orig_nodes)));
2757 0 : new_elem->set_node(17, mesh.node_ptr(elem->node_ptr(5)->id() + ((2*k+1) * orig_nodes)));
2758 :
2759 0 : if (elem->neighbor_ptr(0) == remote_elem)
2760 0 : new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
2761 0 : if (elem->neighbor_ptr(1) == remote_elem)
2762 0 : new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
2763 0 : if (elem->neighbor_ptr(2) == remote_elem)
2764 0 : new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
2765 :
2766 0 : break;
2767 : }
2768 0 : case TRI7:
2769 : {
2770 0 : new_elem = Elem::build(PRISM21);
2771 0 : new_elem->set_node(0, mesh.node_ptr(elem->node_ptr(0)->id() + (2*k * orig_nodes)));
2772 0 : new_elem->set_node(1, mesh.node_ptr(elem->node_ptr(1)->id() + (2*k * orig_nodes)));
2773 0 : new_elem->set_node(2, mesh.node_ptr(elem->node_ptr(2)->id() + (2*k * orig_nodes)));
2774 0 : new_elem->set_node(3, mesh.node_ptr(elem->node_ptr(0)->id() + ((2*k+2) * orig_nodes)));
2775 0 : new_elem->set_node(4, mesh.node_ptr(elem->node_ptr(1)->id() + ((2*k+2) * orig_nodes)));
2776 0 : new_elem->set_node(5, mesh.node_ptr(elem->node_ptr(2)->id() + ((2*k+2) * orig_nodes)));
2777 0 : new_elem->set_node(6, mesh.node_ptr(elem->node_ptr(3)->id() + (2*k * orig_nodes)));
2778 0 : new_elem->set_node(7, mesh.node_ptr(elem->node_ptr(4)->id() + (2*k * orig_nodes)));
2779 0 : new_elem->set_node(8, mesh.node_ptr(elem->node_ptr(5)->id() + (2*k * orig_nodes)));
2780 0 : new_elem->set_node(9, mesh.node_ptr(elem->node_ptr(0)->id() + ((2*k+1) * orig_nodes)));
2781 0 : new_elem->set_node(10, mesh.node_ptr(elem->node_ptr(1)->id() + ((2*k+1) * orig_nodes)));
2782 0 : new_elem->set_node(11, mesh.node_ptr(elem->node_ptr(2)->id() + ((2*k+1) * orig_nodes)));
2783 0 : new_elem->set_node(12, mesh.node_ptr(elem->node_ptr(3)->id() + ((2*k+2) * orig_nodes)));
2784 0 : new_elem->set_node(13, mesh.node_ptr(elem->node_ptr(4)->id() + ((2*k+2) * orig_nodes)));
2785 0 : new_elem->set_node(14, mesh.node_ptr(elem->node_ptr(5)->id() + ((2*k+2) * orig_nodes)));
2786 0 : new_elem->set_node(15, mesh.node_ptr(elem->node_ptr(3)->id() + ((2*k+1) * orig_nodes)));
2787 0 : new_elem->set_node(16, mesh.node_ptr(elem->node_ptr(4)->id() + ((2*k+1) * orig_nodes)));
2788 0 : new_elem->set_node(17, mesh.node_ptr(elem->node_ptr(5)->id() + ((2*k+1) * orig_nodes)));
2789 :
2790 0 : new_elem->set_node(18, mesh.node_ptr(elem->node_ptr(6)->id() + (2*k * orig_nodes)));
2791 0 : new_elem->set_node(19, mesh.node_ptr(elem->node_ptr(6)->id() + ((2*k+2) * orig_nodes)));
2792 0 : new_elem->set_node(20, mesh.node_ptr(elem->node_ptr(6)->id() + ((2*k+1) * orig_nodes)));
2793 :
2794 0 : if (elem->neighbor_ptr(0) == remote_elem)
2795 0 : new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
2796 0 : if (elem->neighbor_ptr(1) == remote_elem)
2797 0 : new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
2798 0 : if (elem->neighbor_ptr(2) == remote_elem)
2799 0 : new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
2800 :
2801 0 : break;
2802 : }
2803 448 : case QUAD4:
2804 : {
2805 640 : new_elem = Elem::build(HEX8);
2806 576 : new_elem->set_node(0, mesh.node_ptr(elem->node_ptr(0)->id() + (k * orig_nodes)));
2807 576 : new_elem->set_node(1, mesh.node_ptr(elem->node_ptr(1)->id() + (k * orig_nodes)));
2808 576 : new_elem->set_node(2, mesh.node_ptr(elem->node_ptr(2)->id() + (k * orig_nodes)));
2809 576 : new_elem->set_node(3, mesh.node_ptr(elem->node_ptr(3)->id() + (k * orig_nodes)));
2810 576 : new_elem->set_node(4, mesh.node_ptr(elem->node_ptr(0)->id() + ((k+1) * orig_nodes)));
2811 576 : new_elem->set_node(5, mesh.node_ptr(elem->node_ptr(1)->id() + ((k+1) * orig_nodes)));
2812 576 : new_elem->set_node(6, mesh.node_ptr(elem->node_ptr(2)->id() + ((k+1) * orig_nodes)));
2813 576 : new_elem->set_node(7, mesh.node_ptr(elem->node_ptr(3)->id() + ((k+1) * orig_nodes)));
2814 :
2815 576 : if (elem->neighbor_ptr(0) == remote_elem)
2816 0 : new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
2817 576 : if (elem->neighbor_ptr(1) == remote_elem)
2818 0 : new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
2819 576 : if (elem->neighbor_ptr(2) == remote_elem)
2820 0 : new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
2821 576 : if (elem->neighbor_ptr(3) == remote_elem)
2822 0 : new_elem->set_neighbor(4, const_cast<RemoteElem *>(remote_elem));
2823 :
2824 128 : break;
2825 : }
2826 350 : case QUAD9:
2827 : {
2828 500 : new_elem = Elem::build(HEX27);
2829 450 : new_elem->set_node(0, mesh.node_ptr(elem->node_ptr(0)->id() + (2*k * orig_nodes)));
2830 450 : new_elem->set_node(1, mesh.node_ptr(elem->node_ptr(1)->id() + (2*k * orig_nodes)));
2831 450 : new_elem->set_node(2, mesh.node_ptr(elem->node_ptr(2)->id() + (2*k * orig_nodes)));
2832 450 : new_elem->set_node(3, mesh.node_ptr(elem->node_ptr(3)->id() + (2*k * orig_nodes)));
2833 450 : new_elem->set_node(4, mesh.node_ptr(elem->node_ptr(0)->id() + ((2*k+2) * orig_nodes)));
2834 450 : new_elem->set_node(5, mesh.node_ptr(elem->node_ptr(1)->id() + ((2*k+2) * orig_nodes)));
2835 450 : new_elem->set_node(6, mesh.node_ptr(elem->node_ptr(2)->id() + ((2*k+2) * orig_nodes)));
2836 450 : new_elem->set_node(7, mesh.node_ptr(elem->node_ptr(3)->id() + ((2*k+2) * orig_nodes)));
2837 450 : new_elem->set_node(8, mesh.node_ptr(elem->node_ptr(4)->id() + (2*k * orig_nodes)));
2838 450 : new_elem->set_node(9, mesh.node_ptr(elem->node_ptr(5)->id() + (2*k * orig_nodes)));
2839 450 : new_elem->set_node(10, mesh.node_ptr(elem->node_ptr(6)->id() + (2*k * orig_nodes)));
2840 450 : new_elem->set_node(11, mesh.node_ptr(elem->node_ptr(7)->id() + (2*k * orig_nodes)));
2841 450 : new_elem->set_node(12, mesh.node_ptr(elem->node_ptr(0)->id() + ((2*k+1) * orig_nodes)));
2842 450 : new_elem->set_node(13, mesh.node_ptr(elem->node_ptr(1)->id() + ((2*k+1) * orig_nodes)));
2843 450 : new_elem->set_node(14, mesh.node_ptr(elem->node_ptr(2)->id() + ((2*k+1) * orig_nodes)));
2844 450 : new_elem->set_node(15, mesh.node_ptr(elem->node_ptr(3)->id() + ((2*k+1) * orig_nodes)));
2845 450 : new_elem->set_node(16, mesh.node_ptr(elem->node_ptr(4)->id() + ((2*k+2) * orig_nodes)));
2846 450 : new_elem->set_node(17, mesh.node_ptr(elem->node_ptr(5)->id() + ((2*k+2) * orig_nodes)));
2847 450 : new_elem->set_node(18, mesh.node_ptr(elem->node_ptr(6)->id() + ((2*k+2) * orig_nodes)));
2848 450 : new_elem->set_node(19, mesh.node_ptr(elem->node_ptr(7)->id() + ((2*k+2) * orig_nodes)));
2849 450 : new_elem->set_node(20, mesh.node_ptr(elem->node_ptr(8)->id() + (2*k * orig_nodes)));
2850 450 : new_elem->set_node(21, mesh.node_ptr(elem->node_ptr(4)->id() + ((2*k+1) * orig_nodes)));
2851 450 : new_elem->set_node(22, mesh.node_ptr(elem->node_ptr(5)->id() + ((2*k+1) * orig_nodes)));
2852 450 : new_elem->set_node(23, mesh.node_ptr(elem->node_ptr(6)->id() + ((2*k+1) * orig_nodes)));
2853 450 : new_elem->set_node(24, mesh.node_ptr(elem->node_ptr(7)->id() + ((2*k+1) * orig_nodes)));
2854 450 : new_elem->set_node(25, mesh.node_ptr(elem->node_ptr(8)->id() + ((2*k+2) * orig_nodes)));
2855 450 : new_elem->set_node(26, mesh.node_ptr(elem->node_ptr(8)->id() + ((2*k+1) * orig_nodes)));
2856 :
2857 450 : if (elem->neighbor_ptr(0) == remote_elem)
2858 0 : new_elem->set_neighbor(1, const_cast<RemoteElem *>(remote_elem));
2859 450 : if (elem->neighbor_ptr(1) == remote_elem)
2860 0 : new_elem->set_neighbor(2, const_cast<RemoteElem *>(remote_elem));
2861 450 : if (elem->neighbor_ptr(2) == remote_elem)
2862 0 : new_elem->set_neighbor(3, const_cast<RemoteElem *>(remote_elem));
2863 450 : if (elem->neighbor_ptr(3) == remote_elem)
2864 0 : new_elem->set_neighbor(4, const_cast<RemoteElem *>(remote_elem));
2865 :
2866 100 : break;
2867 : }
2868 0 : default:
2869 : {
2870 0 : libmesh_not_implemented();
2871 : break;
2872 : }
2873 : }
2874 :
2875 966 : new_elem->set_id(elem->id() + (k * orig_elem));
2876 966 : new_elem->processor_id() = elem->processor_id();
2877 :
2878 : #ifdef LIBMESH_ENABLE_UNIQUE_ID
2879 : // Let's give the base of the extruded mesh the same
2880 : // unique_ids as the source mesh, in case anyone finds that
2881 : // a useful map to preserve.
2882 966 : const unique_id_type uid = (k == 0) ?
2883 260 : elem->unique_id() :
2884 511 : orig_unique_ids + (k-1)*(orig_nodes + orig_elem) + orig_nodes + elem->id();
2885 :
2886 276 : new_elem->set_unique_id(uid);
2887 : #endif
2888 :
2889 966 : if (!elem_subdomain)
2890 : // maintain the subdomain_id
2891 518 : new_elem->subdomain_id() = elem->subdomain_id();
2892 : else
2893 : // Allow the user to choose new subdomain_ids
2894 448 : new_elem->subdomain_id() = elem_subdomain->get_subdomain_for_layer(elem, k);
2895 :
2896 1242 : Elem * added_elem = mesh.add_elem(std::move(new_elem));
2897 :
2898 : // Copy any old boundary ids on all sides
2899 4938 : for (auto s : elem->side_index_range())
2900 : {
2901 3696 : cross_section_boundary_info.boundary_ids(elem, s, ids_to_copy);
2902 :
2903 3696 : if (added_elem->dim() == 3)
2904 : {
2905 : // For 2D->3D extrusion, we give the boundary IDs
2906 : // for side s on the old element to side s+1 on the
2907 : // new element. This is just a happy coincidence as
2908 : // far as I can tell...
2909 3696 : boundary_info.add_side(added_elem,
2910 2640 : cast_int<unsigned short>(s+1),
2911 : ids_to_copy);
2912 : }
2913 : else
2914 : {
2915 : // For 1D->2D extrusion, the boundary IDs map as:
2916 : // Old elem -> New elem
2917 : // 0 -> 3
2918 : // 1 -> 1
2919 0 : libmesh_assert_less(s, 2);
2920 0 : const unsigned short sidemap[2] = {3, 1};
2921 0 : boundary_info.add_side(added_elem, sidemap[s], ids_to_copy);
2922 : }
2923 : }
2924 :
2925 : // Give new boundary ids to bottom and top
2926 966 : if (k == 0)
2927 455 : boundary_info.add_side(added_elem, 0, next_side_id);
2928 966 : if (k == nz-1)
2929 : {
2930 : // For 2D->3D extrusion, the "top" ID is 1+the original
2931 : // element's number of sides. For 1D->2D extrusion, the
2932 : // "top" ID is side 2.
2933 455 : const unsigned short top_id = added_elem->dim() == 3 ?
2934 455 : cast_int<unsigned short>(elem->n_sides()+1) : 2;
2935 : boundary_info.add_side
2936 455 : (added_elem, top_id,
2937 455 : cast_int<boundary_id_type>(next_side_id+1));
2938 : }
2939 414 : }
2940 21 : }
2941 :
2942 : // Done building the mesh. Now prepare it for use.
2943 49 : mesh.prepare_for_use();
2944 : }
2945 :
2946 :
2947 :
2948 :
2949 : #if defined(LIBMESH_HAVE_TRIANGLE) && LIBMESH_DIM > 1
2950 :
2951 : // Triangulates a 2D rectangular region with or without holes
2952 0 : void MeshTools::Generation::build_delaunay_square(UnstructuredMesh & mesh,
2953 : const unsigned int nx, // num. of elements in x-dir
2954 : const unsigned int ny, // num. of elements in y-dir
2955 : const Real xmin, const Real xmax,
2956 : const Real ymin, const Real ymax,
2957 : const ElemType type,
2958 : const std::vector<TriangleInterface::Hole*> * holes)
2959 : {
2960 : // Check for reasonable size
2961 0 : libmesh_assert_greater_equal (nx, 1); // need at least 1 element in x-direction
2962 0 : libmesh_assert_greater_equal (ny, 1); // need at least 1 element in y-direction
2963 0 : libmesh_assert_less (xmin, xmax);
2964 0 : libmesh_assert_less (ymin, ymax);
2965 :
2966 : // Clear out any data which may have been in the Mesh
2967 0 : mesh.clear();
2968 :
2969 0 : BoundaryInfo & boundary_info = mesh.get_boundary_info();
2970 :
2971 : // Make sure the new Mesh will be 2D
2972 0 : mesh.set_mesh_dimension(2);
2973 :
2974 : // The x and y spacing between boundary points
2975 0 : const Real delta_x = (xmax-xmin) / static_cast<Real>(nx);
2976 0 : const Real delta_y = (ymax-ymin) / static_cast<Real>(ny);
2977 :
2978 : // Bottom
2979 0 : for (unsigned int p=0; p<=nx; ++p)
2980 0 : mesh.add_point(Point(xmin + p*delta_x, ymin));
2981 :
2982 : // Right side
2983 0 : for (unsigned int p=1; p<ny; ++p)
2984 0 : mesh.add_point(Point(xmax, ymin + p*delta_y));
2985 :
2986 : // Top
2987 0 : for (unsigned int p=0; p<=nx; ++p)
2988 0 : mesh.add_point(Point(xmax - p*delta_x, ymax));
2989 :
2990 : // Left side
2991 0 : for (unsigned int p=1; p<ny; ++p)
2992 0 : mesh.add_point(Point(xmin, ymax - p*delta_y));
2993 :
2994 : // Be sure we added as many points as we thought we did
2995 0 : libmesh_assert_equal_to (mesh.n_nodes(), 2*(nx+ny));
2996 :
2997 : // Construct the Triangle Interface object
2998 0 : TriangleInterface t(mesh);
2999 :
3000 : // Set custom variables for the triangulation
3001 0 : t.desired_area() = 0.5 * (xmax-xmin)*(ymax-ymin) / static_cast<Real>(nx*ny);
3002 0 : t.triangulation_type() = TriangleInterface::PSLG;
3003 0 : t.elem_type() = type;
3004 :
3005 0 : if (holes != nullptr)
3006 0 : t.attach_hole_list(holes);
3007 :
3008 : // Triangulate!
3009 0 : t.triangulate();
3010 :
3011 : // For avoiding extraneous side element construction
3012 0 : std::unique_ptr<const Elem> side;
3013 :
3014 : // The mesh is now generated, but we still need to mark the boundaries
3015 : // to be consistent with the other build_square routines. Note that all
3016 : // hole boundary elements get the same ID, 4.
3017 0 : for (auto & elem : mesh.element_ptr_range())
3018 0 : for (auto s : elem->side_index_range())
3019 0 : if (elem->neighbor_ptr(s) == nullptr)
3020 : {
3021 0 : elem->build_side_ptr(side, s);
3022 :
3023 : // Check the location of the side's midpoint. Since
3024 : // the square has straight sides, the midpoint is not
3025 : // on the corner and thus it is uniquely on one of the
3026 : // sides.
3027 0 : Point side_midpoint= 0.5f*( side->point(0) + side->point(1) );
3028 :
3029 : // The boundary ids are set following the same convention as Quad4 sides
3030 : // bottom = 0
3031 : // right = 1
3032 : // top = 2
3033 : // left = 3
3034 : // hole = 4
3035 0 : boundary_id_type bc_id=4;
3036 :
3037 : // bottom
3038 0 : if (std::fabs(side_midpoint(1) - ymin) < TOLERANCE)
3039 0 : bc_id=0;
3040 :
3041 : // right
3042 0 : else if (std::fabs(side_midpoint(0) - xmax) < TOLERANCE)
3043 0 : bc_id=1;
3044 :
3045 : // top
3046 0 : else if (std::fabs(side_midpoint(1) - ymax) < TOLERANCE)
3047 0 : bc_id=2;
3048 :
3049 : // left
3050 0 : else if (std::fabs(side_midpoint(0) - xmin) < TOLERANCE)
3051 0 : bc_id=3;
3052 :
3053 : // If the point is not on any of the external boundaries, it
3054 : // is on one of the holes....
3055 :
3056 : // Finally, add this element's information to the boundary info object.
3057 0 : boundary_info.add_side(elem->id(), s, bc_id);
3058 : }
3059 :
3060 0 : } // end build_delaunay_square
3061 :
3062 : #endif // LIBMESH_HAVE_TRIANGLE && LIBMESH_DIM > 1
3063 :
3064 :
3065 70 : void MeshTools::Generation::surface_octahedron
3066 : (UnstructuredMesh & mesh,
3067 : Real xmin, Real xmax,
3068 : Real ymin, Real ymax,
3069 : Real zmin, Real zmax,
3070 : bool flip_tris)
3071 : {
3072 70 : const Real xavg = (xmin + xmax)/2;
3073 70 : const Real yavg = (ymin + ymax)/2;
3074 70 : const Real zavg = (zmin + zmax)/2;
3075 90 : mesh.add_point(Point(xavg,yavg,zmin), 0);
3076 90 : mesh.add_point(Point(xmax,yavg,zavg), 1);
3077 90 : mesh.add_point(Point(xavg,ymax,zavg), 2);
3078 90 : mesh.add_point(Point(xmin,yavg,zavg), 3);
3079 90 : mesh.add_point(Point(xavg,ymin,zavg), 4);
3080 90 : mesh.add_point(Point(xavg,yavg,zmax), 5);
3081 :
3082 4192 : auto add_tri = [&mesh, flip_tris](std::array<dof_id_type,3> nodes)
3083 : {
3084 560 : auto elem = mesh.add_elem(Elem::build(TRI3));
3085 560 : elem->set_node(0, mesh.node_ptr(nodes[0]));
3086 560 : elem->set_node(1, mesh.node_ptr(nodes[1]));
3087 560 : elem->set_node(2, mesh.node_ptr(nodes[2]));
3088 560 : if (flip_tris)
3089 144 : elem->flip(&mesh.get_boundary_info());
3090 580 : };
3091 :
3092 70 : add_tri({0,2,1});
3093 70 : add_tri({0,3,2});
3094 70 : add_tri({0,4,3});
3095 70 : add_tri({0,1,4});
3096 70 : add_tri({5,4,1});
3097 70 : add_tri({5,3,4});
3098 70 : add_tri({5,2,3});
3099 70 : add_tri({5,1,2});
3100 :
3101 70 : mesh.prepare_for_use();
3102 70 : }
3103 :
3104 :
3105 : } // namespace libMesh
|