LCOV - code coverage report
Current view: top level - src/mesh - mesh_generation.C (source / functions) Hit Total Coverage
Test: libMesh/libmesh: #4620 (a489da) with base 3f0912 Lines: 1216 1492 81.5 %
Date: 2026-11-19 19:20:12 Functions: 15 23 65.2 %
Legend: Lines: hit not hit

          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

Generated by: LCOV version 1.14