MeshTools::all_rbb() to generate IGA rational quadratic meshes

include/mesh/mesh_generation.h

@@ -114,8 +114,8 @@ void build_square (UnstructuredMesh & mesh,
  * Meshes a spherical or mapped-spherical domain.
  */
 void build_sphere (UnstructuredMesh & mesh,
-                   const Real rad=1,
-                   const unsigned int nr=2,
+                   const Real radius=1,
+                   const unsigned int n_refinements=2,
                    const ElemType type=INVALID_ELEM,
                    const unsigned int n_smooth=2,
                    const bool flat=true);

include/mesh/mesh_modification.h

@@ -141,6 +141,14 @@ void scale (MeshBase & mesh,
  */
 void all_tri (MeshBase & mesh);
 
+/**
+ * Converts all element geometric mappings from the default Lagrange
+ * to the more flexible Rational-Bezier-Bernstein.  When elements have
+ * curved edges and/or faces, node weights are chosen so that the new
+ * edges interpolate the old edge node locations with a circular arc.
+ */
+void all_rbb (MeshBase & mesh);
+
 /**
  * Smooth the mesh with a simple Laplace smoothing algorithm.  The mesh is
  * smoothed \p n_iterations times.  If the parameter \p power is 0, each

src/geom/cell_c0polyhedron.C

@@ -199,7 +199,9 @@ void C0Polyhedron::connectivity(const unsigned int /*sf*/,
 
 Real C0Polyhedron::volume () const
 {
-  // This specialization is good for Lagrange mappings only
+  // This specialization is ... probably good for general non-Lagrange
+  // mappings, since we require our polyhedral faces to be planar, but
+  // I'd rather be slow than wrong.
   if (this->mapping_type() != LAGRANGE_MAP)
     return this->Elem::volume();
 

src/geom/cell_hex20.C

@@ -321,7 +321,7 @@ Hex20::second_order_child_vertex (const unsigned int n) const
 
 Real Hex20::volume () const
 {
-  // This specialization is good for Lagrange mappings only
+  // This specialization is good for Lagrange mappings only in general
   if (this->mapping_type() != LAGRANGE_MAP)
     return this->Elem::volume();
 

src/geom/cell_hex27.C

@@ -559,7 +559,7 @@ Hex27::second_order_child_vertex (const unsigned int n) const
 
 Real Hex27::volume () const
 {
-  // This specialization is good for Lagrange mappings only
+  // This specialization is good for Lagrange mappings only in general
   if (this->mapping_type() != LAGRANGE_MAP)
     return this->Elem::volume();
 

src/geom/cell_hex8.C

@@ -414,6 +414,10 @@ Point Hex8::true_centroid () const
 
 Real Hex8::volume () const
 {
+  // This specialization is good for Lagrange mappings only in general
+  if (this->mapping_type() != LAGRANGE_MAP)
+    return this->Elem::volume();
+
   // Make copies of our points.  It makes the subsequent calculations a bit
   // shorter and avoids dereferencing the same pointer multiple times.
   Point

src/geom/cell_prism15.C

@@ -351,7 +351,7 @@ Prism15::second_order_child_vertex (const unsigned int n) const
 
 Real Prism15::volume () const
 {
-  // This specialization is good for Lagrange mappings only
+  // This specialization is good for Lagrange mappings only in general
   if (this->mapping_type() != LAGRANGE_MAP)
     return this->Elem::volume();
 

src/geom/cell_prism18.C

@@ -572,7 +572,7 @@ Prism18::second_order_child_vertex (const unsigned int n) const
 
 Real Prism18::volume () const
 {
-  // This specialization is good for Lagrange mappings only
+  // This specialization is good for Lagrange mappings only in general
   if (this->mapping_type() != LAGRANGE_MAP)
     return this->Elem::volume();
 

src/geom/cell_prism6.C

@@ -436,6 +436,10 @@ Point Prism6::true_centroid () const
 
 Real Prism6::volume () const
 {
+  // This specialization is good for Lagrange mappings only in general
+  if (this->mapping_type() != LAGRANGE_MAP)
+    return this->Elem::volume();
+
   VolumeIntegral vi;
   cell_integral(this, vi);
   return vi.vol;

src/geom/cell_pyramid13.C

@@ -351,7 +351,7 @@ unsigned short int Pyramid13::second_order_adjacent_vertex (const unsigned int n
 
 Real Pyramid13::volume () const
 {
-  // This specialization is good for Lagrange mappings only
+  // This specialization is good for Lagrange mappings only in general
   if (this->mapping_type() != LAGRANGE_MAP)
     return this->Elem::volume();
 

src/geom/cell_pyramid14.C

@@ -389,7 +389,7 @@ unsigned short int Pyramid14::second_order_adjacent_vertex (const unsigned int n
 
 Real Pyramid14::volume () const
 {
-  // This specialization is good for Lagrange mappings only
+  // This specialization is good for Lagrange mappings only in general
   if (this->mapping_type() != LAGRANGE_MAP)
     return this->Elem::volume();
 

src/geom/cell_pyramid5.C

@@ -245,6 +245,10 @@ Point Pyramid5::true_centroid () const
 
 Real Pyramid5::volume () const
 {
+  // This specialization is good for Lagrange mappings only in general
+  if (this->mapping_type() != LAGRANGE_MAP)
+    return this->Elem::volume();
+
   // The pyramid with a bilinear base has volume given by the
   // formula in: "Calculation of the Volume of a General Hexahedron
   // for Flow Predictions", AIAA Journal v.23, no.6, 1984, p.954-

src/geom/cell_tet10.C

@@ -621,7 +621,7 @@ Real Tet10::embedding_matrix (const unsigned int i,
 
 Real Tet10::volume () const
 {
-  // This specialization is good for Lagrange mappings only
+  // This specialization is good for Lagrange mappings only in general
   if (this->mapping_type() != LAGRANGE_MAP)
     return this->Elem::volume();
 

src/geom/cell_tet4.C

@@ -316,6 +316,9 @@ Point Tet4::true_centroid () const
 
 Real Tet4::volume () const
 {
+  // This specialization is good for non-Lagrange mappings too!  Even
+  // with differing vertex weights we've still got p=1 planar faces.
+
   // The volume of a tetrahedron is 1/6 the box product formed
   // by its base and apex vectors
   Point a = point(3) - point(0);

src/geom/edge_edge3.C

@@ -223,6 +223,10 @@ Edge3::second_order_child_vertex (const unsigned int) const
 
 Real Edge3::volume () const
 {
+  // This specialization is good for Lagrange mappings only in general
+  if (this->mapping_type() != LAGRANGE_MAP)
+    return this->Elem::volume();
+
   // Finding the (exact) length of a general quadratic element
   // is a surprisingly complicated formula.
   Point A = this->point(0) + this->point(1) - 2*this->point(2);

src/geom/edge_edge4.C

@@ -298,6 +298,10 @@ dof_id_type Edge4::key () const
 
 Real Edge4::volume () const
 {
+  // This specialization is good for Lagrange mappings only in general
+  if (this->mapping_type() != LAGRANGE_MAP)
+    return this->Elem::volume();
+
   // Make copies of our points.  It makes the subsequent calculations a bit
   // shorter and avoids dereferencing the same pointer multiple times.
   Point

src/geom/elem.C

@@ -682,11 +682,15 @@ Point Elem::vertex_average() const
 
 Real Elem::hmin() const
 {
-  Real h_min=std::numeric_limits<Real>::max();
-
   // Avoid calling a virtual a lot of times
   const auto n_vertices = this->n_vertices();
 
+  // Special case for NodeElem
+  if (!n_vertices)
+    return 0;
+
+  Real h_min=std::numeric_limits<Real>::max();
+
   for (unsigned int n_outer=0; n_outer<n_vertices; n_outer++)
     for (unsigned int n_inner=n_outer+1; n_inner<n_vertices; n_inner++)
       {

src/geom/face_c0polygon.C

@@ -215,9 +215,11 @@ void C0Polygon::connectivity(const unsigned int /*sf*/,
 
 Real C0Polygon::volume () const
 {
-  // This specialization is good for Lagrange mappings only
-  if (this->mapping_type() != LAGRANGE_MAP)
-    return this->Elem::volume();
+  // This specialization is good for non-Lagrange mappings, but
+  // remember to be more careful when we extend it to non-planar or
+  // non p=1 polygon types.
+  // if (this->mapping_type() != LAGRANGE_MAP)
+  //   return this->Elem::volume();
 
   // We use a triangulation to calculate here; assert that it's as
   // consistent as possible.

src/geom/face_quad4.C

@@ -311,6 +311,12 @@ Point Quad4::true_centroid () const
 
 Real Quad4::volume () const
 {
+  // This specialization is good for Lagrange mappings only in general
+  // (consider that we might have a non-planar quad with non-equal
+  // vertex weights)
+  if (this->mapping_type() != LAGRANGE_MAP)
+    return this->Elem::volume();
+
   // Make copies of our points.  It makes the subsequent calculations a bit
   // shorter and avoids dereferencing the same pointer multiple times.
   Point

src/geom/face_tri3.C

@@ -190,6 +190,9 @@ Point Tri3::true_centroid () const
 
 Real Tri3::volume () const
 {
+  // This specialization is good for non-Lagrange mappings too!  Even
+  // with differing vertex weights we've still got a p=1 planar face.
+
   // 3-node triangles have the following formula for computing the area
   return 0.5 * cross_norm(point(1) - point(0),
                           point(2) - point(0));

src/geom/face_tri6.C

@@ -323,7 +323,7 @@ BoundingBox Tri6::loose_bounding_box () const
 
 Real Tri6::volume () const
 {
-  // This specialization is good for Lagrange mappings only
+  // This specialization is good for Lagrange mappings only in general
   if (this->mapping_type() != LAGRANGE_MAP)
     return this->Elem::volume();