AllRBBTest Class Reference

Inheritance diagram for AllRBBTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (AllRBBTest)
	The goal of this test is to verify proper operation of the all_rbb() mesh modification, by converting meshes of classic "isogeometric" types from Lagrange interpolants to Rational Bezier-Bernstein splines, then verifying that the converted geometry is exact to within floating-point error (for point radii) or quadrature error (for element volume).
	CPPUNIT_TEST (testAllRBBNodeElem)
	CPPUNIT_TEST (testAllRBBEdge)
	CPPUNIT_TEST (testAllRBBEdge3)
	CPPUNIT_TEST (testAllRBBTri)
	CPPUNIT_TEST (testAllRBBTri6)
	CPPUNIT_TEST (testAllRBBQuad)
	CPPUNIT_TEST (testAllRBBQuad8)
	CPPUNIT_TEST (testAllRBBQuad9)
	CPPUNIT_TEST (testAllRBBCircle4)
	CPPUNIT_TEST (testAllRBBCircle8)
	CPPUNIT_TEST (testAllRBBCircle16)
	CPPUNIT_TEST (testAllRBBDisk5)
	CPPUNIT_TEST (testAllRBBDisk20)
	CPPUNIT_TEST (testAllRBBDisk80)
	CPPUNIT_TEST (testAllRBBTri6Disk10)
	CPPUNIT_TEST (testAllRBBTri6Disk40)
	CPPUNIT_TEST (testAllRBBTri6Disk160)
	CPPUNIT_TEST (testAllRBBTet)
	CPPUNIT_TEST (testAllRBBTet10)
	CPPUNIT_TEST (testAllRBBHex)
	CPPUNIT_TEST (testAllRBBHex20)
	CPPUNIT_TEST (testAllRBBHex27)
	CPPUNIT_TEST (testAllRBBCylinder10)
	CPPUNIT_TEST (testAllRBBCylinder80)
	CPPUNIT_TEST (testAllRBBSphere6)
	CPPUNIT_TEST (testAllRBBSphere24)
	CPPUNIT_TEST (testAllRBBSphere96)
	CPPUNIT_TEST (testAllRBBTri6Sphere12)
	CPPUNIT_TEST (testAllRBBTri6Sphere48)
	CPPUNIT_TEST (testAllRBBTri6Sphere192)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testAllRBBNodeElem ()
void	testAllRBBEdge ()
void	testAllRBBEdge3 ()
void	testAllRBBTri ()
void	testAllRBBTri6 ()
void	testAllRBBQuad ()
void	testAllRBBQuad8 ()
void	testAllRBBQuad9 ()
void	testAllRBBTet ()
void	testAllRBBTet10 ()
void	testAllRBBHex ()
void	testAllRBBHex20 ()
void	testAllRBBHex27 ()
void	testAllRBBCircle4 ()
void	testAllRBBCircle8 ()
void	testAllRBBCircle16 ()
void	testAllRBBDisk5 ()
void	testAllRBBDisk20 ()
void	testAllRBBDisk80 ()
void	testAllRBBTri6Disk10 ()
void	testAllRBBTri6Disk40 ()
void	testAllRBBTri6Disk160 ()
void	testAllRBBCylinder10 ()
void	testAllRBBCylinder80 ()
void	testAllRBBSphere6 ()
void	testAllRBBSphere24 ()
void	testAllRBBSphere96 ()
void	testAllRBBTri6Sphere12 ()
void	testAllRBBTri6Sphere48 ()
void	testAllRBBTri6Sphere192 ()

Protected Member Functions
void	test_box (ElemType elem_type)
void	test_circle (unsigned int n_refinements)
void	test_disk (unsigned int n_refinements, const ElemType type=QUAD9)
void	test_cylinder (unsigned int n_refinements, const ElemType type=HEX27)
void	test_sphere (unsigned int n_refinements, const ElemType type=QUAD9)

Detailed Description

Definition at line 17 of file all_rbb.C.

Member Function Documentation

CPPUNIT_TEST() [1/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBCircle16

)

CPPUNIT_TEST() [2/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBCircle4

)

CPPUNIT_TEST() [3/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBCircle8

)

CPPUNIT_TEST() [4/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBCylinder10

)

CPPUNIT_TEST() [5/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBCylinder80

)

CPPUNIT_TEST() [6/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBDisk20

)

CPPUNIT_TEST() [7/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBDisk5

)

CPPUNIT_TEST() [8/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBDisk80

)

CPPUNIT_TEST() [9/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBEdge

)

CPPUNIT_TEST() [10/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBEdge3

)

CPPUNIT_TEST() [11/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBHex

)

CPPUNIT_TEST() [12/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBHex20

)

CPPUNIT_TEST() [13/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBHex27

)

CPPUNIT_TEST() [14/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBNodeElem

)

CPPUNIT_TEST() [15/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBQuad

)

CPPUNIT_TEST() [16/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBQuad8

)

CPPUNIT_TEST() [17/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBQuad9

)

CPPUNIT_TEST() [18/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBSphere24

)

CPPUNIT_TEST() [19/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBSphere6

)

CPPUNIT_TEST() [20/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBSphere96

)

CPPUNIT_TEST() [21/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTet

)

CPPUNIT_TEST() [22/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTet10

)

CPPUNIT_TEST() [23/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTri

)

CPPUNIT_TEST() [24/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTri6

)

CPPUNIT_TEST() [25/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTri6Disk10

)

CPPUNIT_TEST() [26/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTri6Disk160

)

CPPUNIT_TEST() [27/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTri6Disk40

)

CPPUNIT_TEST() [28/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTri6Sphere12

)

CPPUNIT_TEST() [29/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTri6Sphere192

)

CPPUNIT_TEST() [30/30]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTri6Sphere48

)

CPPUNIT_TEST_SUITE_END()

AllRBBTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

AllRBBTest::LIBMESH_CPPUNIT_TEST_SUITE

(

AllRBBTest

)

The goal of this test is to verify proper operation of the all_rbb() mesh modification, by converting meshes of classic "isogeometric" types from Lagrange interpolants to Rational Bezier-Bernstein splines, then verifying that the converted geometry is exact to within floating-point error (for point radii) or quadrature error (for element volume).

setUp()

void AllRBBTest::setUp ( )

inline

Definition at line 518 of file all_rbb.C.

{}

tearDown()

void AllRBBTest::tearDown ( )

inline

Definition at line 520 of file all_rbb.C.

{}

test_box()

void AllRBBTest::test_box ( ElemType  elem_type )

inlineprotected

Definition at line 91 of file all_rbb.C.

  {
    Mesh mesh(*TestCommWorld);
 
    auto dim = Elem::type_to_dim_map[elem_type];
 
    MeshTools::Generation::build_cube(mesh,
                                        dim > 0 ? 2 : 0, dim > 1 ? 1 : 0, dim > 2 ? 1 : 0,
                                        0., 1.,
                                        0., 1.,
                                        0., 1.,
                                        elem_type);
 
    const auto n_orig_elem = mesh.n_elem();
    CPPUNIT_ASSERT_EQUAL(n_orig_elem, mesh.max_elem_id());
 
    const Real orig_volume = MeshTools::volume(mesh) / n_orig_elem;
 
    std::vector<Real> orig_hmin(n_orig_elem), orig_hmax(n_orig_elem);
 
    // In the tet case our elements all have the same volume but
    // they're stretched differently and have different hmin/hmax
    for (auto & elem : mesh.element_ptr_range())
    {
      orig_hmin[elem->id()] = elem->hmin();
      orig_hmax[elem->id()] = elem->hmax();
    }
 
    MeshTools::Modification::all_rbb(mesh);
 
    CPPUNIT_ASSERT_EQUAL(n_orig_elem, mesh.n_elem());
    CPPUNIT_ASSERT_EQUAL(n_orig_elem, mesh.max_elem_id());
 
    unsigned char weight_index = mesh.default_mapping_data();
 
    for (auto & elem : mesh.element_ptr_range())
    {
      CPPUNIT_ASSERT_EQUAL(elem->mapping_type(),
                           RATIONAL_BERNSTEIN_MAP);
      CPPUNIT_ASSERT(elem->has_affine_map());
 
      // Tri6 has this much FP error??
      LIBMESH_ASSERT_FP_EQUAL(elem->volume(), orig_volume,
                              20*TOLERANCE*TOLERANCE);
      LIBMESH_ASSERT_FP_EQUAL(elem->hmax(), orig_hmax[elem->id()],
                              TOLERANCE*TOLERANCE);
      LIBMESH_ASSERT_FP_EQUAL(elem->hmin(), orig_hmin[elem->id()],
                              TOLERANCE*TOLERANCE);
    }
 
    for (auto & node : mesh.node_ptr_range())
    {
      const Real w = node->get_extra_datum<Real>(weight_index);
 
      CPPUNIT_ASSERT_EQUAL(Real(1), w);
    }
  }

References libMesh::MeshTools::Modification::all_rbb(), libMesh::MeshTools::Generation::build_cube(), libMesh::MeshBase::default_mapping_data(), dim, libMesh::MeshBase::max_elem_id(), mesh, libMesh::MeshBase::n_elem(), libMesh::RATIONAL_BERNSTEIN_MAP, libMesh::Real, TestCommWorld, libMesh::TOLERANCE, libMesh::Elem::type_to_dim_map, and libMesh::MeshTools::volume().

Referenced by testAllRBBEdge(), testAllRBBEdge3(), testAllRBBHex(), testAllRBBHex20(), testAllRBBHex27(), testAllRBBNodeElem(), testAllRBBQuad(), testAllRBBQuad8(), testAllRBBQuad9(), testAllRBBTet(), testAllRBBTet10(), testAllRBBTri(), and testAllRBBTri6().

test_circle()

void AllRBBTest::test_circle ( unsigned int  n_refinements )

inlineprotected

Definition at line 149 of file all_rbb.C.

  {
    Mesh interior_mesh(*TestCommWorld),
         boundary_mesh(*TestCommWorld);
 
    const Real radius = 1;
    const Real circumference = 2 * pi * radius;
    const Real tol = TOLERANCE*TOLERANCE;
 
    // Build a filled circle
    MeshTools::Generation::build_sphere (interior_mesh, radius,
                                         n_refinements, QUAD9);
 
    // Get just the outer EDGE3 circle mesh
    interior_mesh.get_boundary_info().sync(boundary_mesh);
 
    const dof_id_type n_edges = 4 << n_refinements;
 
    CPPUNIT_ASSERT_EQUAL(boundary_mesh.n_elem(), n_edges);
    CPPUNIT_ASSERT_EQUAL(boundary_mesh.n_nodes(), n_edges*2);
 
    for (auto & node : boundary_mesh.node_ptr_range())
      {
        const Point p = *node;
        LIBMESH_ASSERT_FP_EQUAL(p.norm(), radius, tol);
      }
 
    // We just did Lagrange interpolation, so our mesh measure
    // shouldn't be *quite* right.  Empirically, we converge from
    // beneath, and our error looks like Ch^4.
    const Real max_lagrange_error =
      radius * 5e-2 / (1 << (4*n_refinements));
    LIBMESH_ASSERT_FP_EQUAL(MeshTools::volume(boundary_mesh),
                            circumference, max_lagrange_error);
 
    MeshTools::Modification::all_rbb(boundary_mesh);
 
    for (auto & elem : boundary_mesh.element_ptr_range())
      {
        CPPUNIT_ASSERT_EQUAL(RATIONAL_BERNSTEIN_MAP, elem->mapping_type());
 
        // We can no longer assert that each Node is at a specified
        // radius from the circle center, because these are now spline
        // control nodes, but we can assert that physical points
        // within the element are at the desired radius.
        constexpr int n_intervals = 4;
        Point master_pt;
        for (master_pt(0) = -1; master_pt(0) <= 1 + TOLERANCE;
             master_pt(0) += Real(2)/n_intervals)
          {
            const Point p = FEMap::map(elem->dim(), elem, master_pt);
            LIBMESH_ASSERT_FP_EQUAL(radius, p.norm(), tol);
          }
      }
 
    // We're using quadrature for volume approximation, so we still
    // have error, but our quadrature error looks something like Ch^6
    // with a much smaller C.
    const Real max_rbb_error =
      radius * 1e-3 / (1 << (6*n_refinements));
    LIBMESH_ASSERT_FP_EQUAL(MeshTools::volume(boundary_mesh),
                            circumference, max_rbb_error);
  }

References libMesh::MeshTools::Modification::all_rbb(), libMesh::MeshTools::Generation::build_sphere(), libMesh::FEMap::map(), libMesh::DistributedMesh::n_elem(), libMesh::DistributedMesh::n_nodes(), libMesh::TypeVector< T >::norm(), libMesh::pi, libMesh::QUAD9, radius, libMesh::RATIONAL_BERNSTEIN_MAP, libMesh::Real, TestCommWorld, libMesh::TOLERANCE, and libMesh::MeshTools::volume().

Referenced by testAllRBBCircle16(), testAllRBBCircle4(), and testAllRBBCircle8().

test_cylinder()

void AllRBBTest::test_cylinder ( unsigned int  n_refinements, const ElemType  type = HEX27  )

inlineprotected

Definition at line 278 of file all_rbb.C.

  {
    Mesh disk_mesh(*TestCommWorld), mesh(*TestCommWorld);
 
    const Real radius = 1;
    const Real height = 3;
    const Real volume = pi * radius * radius * height;
    const Real tol = TOLERANCE*TOLERANCE;
 
    // We're extruding a circle from side 0 up
    const ElemType side_type = Elem::build(type)->side_type(0);
 
    // Build a filled circle
    MeshTools::Generation::build_sphere (disk_mesh, radius,
                                         n_refinements, side_type);
 
    // Then extrude it into a cylinder
    const unsigned int nz = 2;
    const RealVectorValue extrusion_vector{0,0,height};
    MeshTools::Generation::build_extrusion (mesh, disk_mesh, nz, extrusion_vector);
 
    const dof_id_type n_elem =
      (5 << (n_refinements*2)) * (side_type == QUAD9 ? 1 : 2) * nz;
 
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), n_elem);
 
    // We just did Lagrange interpolation, so our mesh measure
    // shouldn't be *quite* right, but we should converge similarly to
    // how we did with the filled disk.
    const Real max_lagrange_error =
      radius * 5e-2 / (1 << (4*n_refinements)) *
      radius * radius * height;
 
    LIBMESH_ASSERT_FP_EQUAL(MeshTools::volume(mesh),
                            volume, max_lagrange_error);
 
    MeshTools::Modification::all_rbb(mesh);
 
    std::unique_ptr<const Elem> elem_side;
    constexpr int n_intervals = 4;
    auto qrule = QBase::build(QGRID, /*dim=*/2, Order(n_intervals));
 
    for (const Elem * elem : mesh.element_ptr_range())
      {
        CPPUNIT_ASSERT_EQUAL(RATIONAL_BERNSTEIN_MAP, elem->mapping_type());
 
        // We cannot assert that each Node is at a specified radius
        // from the cylinder axis, because these are now spline
        // control nodes, but we can assert that physical points
        // within the rounded surface are at the desired radius.
        for (auto s : make_range(elem->n_sides()))
          {
            if (elem->neighbor_ptr(s))
              continue;
 
            const Point side_normal =
              elem->side_vertex_average_normal(s);
 
            // We ought to either be on the rounded surface or the end
            // caps
            if (std::abs(side_normal(2)) > TOLERANCE*TOLERANCE)
              {
                LIBMESH_ASSERT_FP_EQUAL(side_normal(0), 0, TOLERANCE*TOLERANCE);
                LIBMESH_ASSERT_FP_EQUAL(side_normal(1), 0, TOLERANCE*TOLERANCE);
                continue;
              }
 
            elem->build_side_ptr(elem_side, s);
            qrule->init(*elem_side);
 
            for (auto i : make_range(qrule->n_points()))
              {
                Point p = FEMap::map(elem_side->dim(), elem_side.get(), qrule->qp(i));
                p(2) = 0; // Just look at r in cylindrical coordinates
                LIBMESH_ASSERT_FP_EQUAL(radius, p.norm(), tol);
              }
          }
      }
 
    // We're using quadrature for volume approximation, so we still
    // have error, but our quadrature error looks like Ch^6 with a
    // much smaller C.
    const Real max_rbb_error =
      radius * 2e-3 / (1 << (6*n_refinements)) *
      radius * radius * height;
    LIBMESH_ASSERT_FP_EQUAL(MeshTools::volume(mesh),
                            volume, max_rbb_error);
  }

References libMesh::MeshTools::Modification::all_rbb(), libMesh::Elem::build(), libMesh::QBase::build(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshTools::Generation::build_sphere(), libMesh::make_range(), libMesh::FEMap::map(), mesh, libMesh::MeshBase::n_elem(), libMesh::TypeVector< T >::norm(), libMesh::pi, libMesh::QGRID, libMesh::QUAD9, radius, libMesh::RATIONAL_BERNSTEIN_MAP, libMesh::Real, TestCommWorld, libMesh::TOLERANCE, and libMesh::MeshTools::volume().

Referenced by testAllRBBCylinder10(), and testAllRBBCylinder80().

test_disk()

void AllRBBTest::test_disk ( unsigned int  n_refinements, const ElemType  type = QUAD9  )

inlineprotected

Definition at line 213 of file all_rbb.C.

  {
    Mesh mesh(*TestCommWorld);
 
    const Real radius = 1;
    const Real area = pi * radius * radius;
    const Real tol = TOLERANCE*TOLERANCE;
 
    // Build a filled circle
    MeshTools::Generation::build_sphere (mesh, radius,
                                         n_refinements, type);
 
    const dof_id_type n_elem =
      (5 << (n_refinements*2)) * (type == QUAD9 ? 1 : 2);
 
    CPPUNIT_ASSERT_EQUAL(mesh.n_elem(), n_elem);
 
    // We just did Lagrange interpolation, so our mesh measure
    // shouldn't be *quite* right.  Empirically, we converge from
    // beneath, and our error looks like Ch^4.
    const Real max_lagrange_error =
      radius * 5e-2 / (1 << (4*n_refinements));
 
    LIBMESH_ASSERT_FP_EQUAL(MeshTools::volume(mesh),
                            area, max_lagrange_error);
 
    MeshTools::Modification::all_rbb(mesh);
 
    for (const Elem * elem : mesh.element_ptr_range())
      {
        CPPUNIT_ASSERT_EQUAL(RATIONAL_BERNSTEIN_MAP, elem->mapping_type());
 
        // We can no longer assert that each Node is at a specified
        // radius from the circle center, because these are now spline
        // control nodes, but we can assert that physical points
        // within the element are at the desired radius.
        for (auto s : make_range(elem->n_sides()))
          {
            if (elem->neighbor_ptr(s))
              continue;
 
            constexpr int n_intervals = 4;
            Point master_pt = elem->master_point(s);
            const Point step =
              (elem->master_point((s+1)%elem->n_sides()) - master_pt)
              / n_intervals;
            for (auto i : make_range(n_intervals+1))
              {
                libmesh_ignore(i);
                const Point p = FEMap::map(elem->dim(), elem, master_pt);
                LIBMESH_ASSERT_FP_EQUAL(radius, p.norm(), tol);
                master_pt += step;
              }
          }
      }
 
    // We're using quadrature for volume approximation, so we still
    // have error, but our quadrature error looks like Ch^6 with a
    // much smaller C.
    const Real max_rbb_error =
      radius * 2e-3 / (1 << (6*n_refinements));
    LIBMESH_ASSERT_FP_EQUAL(MeshTools::volume(mesh),
                            area, max_rbb_error);
  }

References libMesh::MeshTools::Modification::all_rbb(), libMesh::MeshTools::Generation::build_sphere(), libMesh::libmesh_ignore(), libMesh::make_range(), libMesh::FEMap::map(), mesh, libMesh::MeshBase::n_elem(), libMesh::TypeVector< T >::norm(), libMesh::pi, libMesh::QUAD9, radius, libMesh::RATIONAL_BERNSTEIN_MAP, libMesh::Real, TestCommWorld, libMesh::TOLERANCE, and libMesh::MeshTools::volume().

Referenced by testAllRBBDisk20(), testAllRBBDisk5(), testAllRBBDisk80(), testAllRBBTri6Disk10(), testAllRBBTri6Disk160(), and testAllRBBTri6Disk40().

test_sphere()

void AllRBBTest::test_sphere ( unsigned int  n_refinements, const ElemType  type = QUAD9  )

inlineprotected

Definition at line 367 of file all_rbb.C.

  {
    Mesh interior_mesh(*TestCommWorld),
         boundary_mesh(*TestCommWorld);
 
    const Real radius = 1;
    const Real surface_area = 4 * pi * radius * radius;
    const Real tol = TOLERANCE*TOLERANCE;
 
    // Build a filled sphere.  We're going to avoid using the `flat`
    // direct 2D option here because that only currently supports
    // TRI3.
    MeshTools::Generation::build_sphere (interior_mesh, radius,
                                         n_refinements, HEX27);
 
    // Get just the outer QUAD9 sphere mesh
    interior_mesh.get_boundary_info().sync(boundary_mesh);
 
    const dof_id_type n_faces = 6 << (2*n_refinements);
 
    CPPUNIT_ASSERT_EQUAL(boundary_mesh.n_elem(), n_faces);
 
    auto check_radii = [&boundary_mesh, radius, type](Real radius_tol) {
      constexpr int n_intervals = 4;
 
      Real max_radius_error = 0;
      for (auto & elem : boundary_mesh.element_ptr_range())
        {
          // We can't necessarily assert that each Node is at a
          // specified radius from the circle center, because these
          // may be spline control nodes.  We want physical points
          // within an element to all be at the desired radius, but on
          // rational quadratics that's only possible for "latitude /
          // longitude" quad edges, so we need a non-trivial tolerance
          // here.
          Point master_pt;
          if (type == TRI6)
            {
              for (master_pt(0) = 0; master_pt(0) <= 1 + TOLERANCE;
                   master_pt(0) += Real(1)/n_intervals)
                {
                  for (master_pt(1) = 0; master_pt(1) <= 1 - master_pt(0) + TOLERANCE;
                       master_pt(1) += Real(1)/n_intervals)
                    {
                      const Point p = FEMap::map(elem->dim(), elem, master_pt);
                      max_radius_error = std::max(max_radius_error, std::abs(radius-p.norm()));
                    }
                }
            }
          else
            {
              libmesh_assert_equal_to(type, QUAD9);
              for (master_pt(0) = -1; master_pt(0) <= 1 + TOLERANCE;
                   master_pt(0) += Real(2)/n_intervals)
                {
                  for (master_pt(1) = -1; master_pt(1) <= 1 + TOLERANCE;
                       master_pt(1) += Real(2)/n_intervals)
                    {
                      const Point p = FEMap::map(elem->dim(), elem, master_pt);
                      max_radius_error = std::max(max_radius_error, std::abs(radius-p.norm()));
                    }
                }
            }
          LIBMESH_ASSERT_FP_EQUAL(max_radius_error, 0, radius_tol);
        }
    };
 
    auto verify_equispaced_midnodes = [&boundary_mesh, type]()
    {
      std::unique_ptr<Elem> side_ptr;
      for (auto & elem : boundary_mesh.element_ptr_range())
        {
          // We expect midnodes to be and to remain equispaced on
          // quad edges.  But our QUAD9 elements can be curved
          // trapezoids, so we don't expect "diagonal" edges to have
          // an equispaced mid-face node.
          if (type != TRI6)
            for (auto s : elem->side_index_range())
              {
                elem->build_side_ptr(side_ptr, s);
 
                auto c02 = side_ptr->point(2) - side_ptr->point(0);
                auto c12 = side_ptr->point(2) - side_ptr->point(1);
                LIBMESH_ASSERT_FP_EQUAL
                  (c02.norm_sq(), c12.norm_sq(), TOLERANCE*TOLERANCE);
              }
        }
    };
 
    verify_equispaced_midnodes();
 
    if (type == TRI6)
      {
        MeshTools::Modification::all_tri(boundary_mesh);
        verify_equispaced_midnodes();
      }
    else
      libmesh_assert_equal_to(type, QUAD9);
 
    // For our sphere construction, all of our Lagrange nodes should
    // be at exactly the right radius.
    for (auto & node : boundary_mesh.node_ptr_range())
      {
        const Point p = *node;
        LIBMESH_ASSERT_FP_EQUAL(p.norm(), radius, tol);
      }
 
    // But Lagrange isn't isogeometric, so non-nodes should have
    // radius error.  Empirically, our error looks like Ch^3
    const Real max_lagrange_rad_error =
      radius * 0.2 / (1 << (3*n_refinements));
    check_radii(max_lagrange_rad_error);
 
    // We just did Lagrange interpolation, so our mesh measure
    // shouldn't be *quite* right.  Empirically, we converge from
    // beneath, and our error looks like Ch^4.
    const Real max_lagrange_vol_error =
      radius * radius * 1.5 / (1 << (4*n_refinements));
    LIBMESH_ASSERT_FP_EQUAL(MeshTools::volume(boundary_mesh),
                            surface_area, max_lagrange_vol_error);
 
    MeshTools::Modification::all_rbb(boundary_mesh);
 
    // All of our vertices should still be at exactly the right
    // radius; for these the control point is the point.
    for (auto & elem : boundary_mesh.element_ptr_range())
      {
        CPPUNIT_ASSERT_EQUAL(RATIONAL_BERNSTEIN_MAP, elem->mapping_type());
 
        for (auto v : make_range(elem->n_vertices()))
          {
            const Point & p = elem->point(v);
            LIBMESH_ASSERT_FP_EQUAL(p.norm(), radius, tol);
          }
      }
 
    // We're not building a stereographic mesh on the sphere, so we
    // still have error ... of only slightly better magnitude?
    const Real max_rbb_rad_error =
      radius * 0.2 / (1 << (3*n_refinements));
    check_radii(max_rbb_rad_error);
 
    // And we also get about the same order on volume():
    const Real max_rbb_vol_error =
      radius * radius * 1.5 / (1 << (4*n_refinements));
    LIBMESH_ASSERT_FP_EQUAL(MeshTools::volume(boundary_mesh),
                            surface_area, max_rbb_vol_error);
  }

References libMesh::MeshTools::Modification::all_rbb(), libMesh::MeshTools::Modification::all_tri(), libMesh::MeshTools::Generation::build_sphere(), libMesh::HEX27, libMesh::make_range(), libMesh::FEMap::map(), libMesh::DistributedMesh::n_elem(), libMesh::TypeVector< T >::norm(), libMesh::pi, libMesh::QUAD9, radius, libMesh::RATIONAL_BERNSTEIN_MAP, libMesh::Real, TestCommWorld, libMesh::TOLERANCE, libMesh::TRI6, and libMesh::MeshTools::volume().

Referenced by testAllRBBSphere24(), testAllRBBSphere6(), testAllRBBSphere96(), testAllRBBTri6Sphere12(), testAllRBBTri6Sphere192(), and testAllRBBTri6Sphere48().

testAllRBBCircle16()

void AllRBBTest::testAllRBBCircle16 ( )

inline

Definition at line 546 of file all_rbb.C.

{ LOG_UNIT_TEST; test_circle(2); }

References test_circle().

testAllRBBCircle4()

void AllRBBTest::testAllRBBCircle4 ( )

inline

Definition at line 544 of file all_rbb.C.

{ LOG_UNIT_TEST; test_circle(0); }

References test_circle().

testAllRBBCircle8()

void AllRBBTest::testAllRBBCircle8 ( )

inline

Definition at line 545 of file all_rbb.C.

{ LOG_UNIT_TEST; test_circle(1); }

References test_circle().

testAllRBBCylinder10()

void AllRBBTest::testAllRBBCylinder10 ( )

inline

Definition at line 560 of file all_rbb.C.

{ LOG_UNIT_TEST; test_cylinder(0); }

References test_cylinder().

testAllRBBCylinder80()

void AllRBBTest::testAllRBBCylinder80 ( )

inline

Definition at line 561 of file all_rbb.C.

{ LOG_UNIT_TEST; test_cylinder(1); }

References test_cylinder().

testAllRBBDisk20()

void AllRBBTest::testAllRBBDisk20 ( )

inline

Definition at line 551 of file all_rbb.C.

{ LOG_UNIT_TEST; test_disk(1); }

References test_disk().

testAllRBBDisk5()

void AllRBBTest::testAllRBBDisk5 ( )

inline

Definition at line 550 of file all_rbb.C.

{ LOG_UNIT_TEST; test_disk(0); }

References test_disk().

testAllRBBDisk80()

void AllRBBTest::testAllRBBDisk80 ( )

inline

Definition at line 552 of file all_rbb.C.

{ LOG_UNIT_TEST; test_disk(2); }

References test_disk().

testAllRBBEdge()

void AllRBBTest::testAllRBBEdge ( )

inline

Definition at line 523 of file all_rbb.C.

{ LOG_UNIT_TEST; test_box(EDGE2); }

References libMesh::EDGE2, and test_box().

testAllRBBEdge3()

void AllRBBTest::testAllRBBEdge3 ( )

inline

Definition at line 524 of file all_rbb.C.

{ LOG_UNIT_TEST; test_box(EDGE3); }

References libMesh::EDGE3, and test_box().

testAllRBBHex()

void AllRBBTest::testAllRBBHex ( )

inline

Definition at line 532 of file all_rbb.C.

{ LOG_UNIT_TEST; test_box(HEX8); }

References libMesh::HEX8, and test_box().

testAllRBBHex20()

void AllRBBTest::testAllRBBHex20 ( )

inline

Definition at line 533 of file all_rbb.C.

{ LOG_UNIT_TEST; test_box(HEX20); }

References libMesh::HEX20, and test_box().

testAllRBBHex27()

void AllRBBTest::testAllRBBHex27 ( )

inline

Definition at line 534 of file all_rbb.C.

{ LOG_UNIT_TEST; test_box(HEX27); }

References libMesh::HEX27, and test_box().

testAllRBBNodeElem()

void AllRBBTest::testAllRBBNodeElem ( )

inline

Definition at line 522 of file all_rbb.C.

{ LOG_UNIT_TEST; test_box(NODEELEM); }

References libMesh::NODEELEM, and test_box().

testAllRBBQuad()

void AllRBBTest::testAllRBBQuad ( )

inline

Definition at line 527 of file all_rbb.C.

{ LOG_UNIT_TEST; test_box(QUAD4); }

References libMesh::QUAD4, and test_box().

testAllRBBQuad8()

void AllRBBTest::testAllRBBQuad8 ( )

inline

Definition at line 528 of file all_rbb.C.

{ LOG_UNIT_TEST; test_box(QUAD8); }

References libMesh::QUAD8, and test_box().

testAllRBBQuad9()

void AllRBBTest::testAllRBBQuad9 ( )

inline

Definition at line 529 of file all_rbb.C.

{ LOG_UNIT_TEST; test_box(QUAD9); }

References libMesh::QUAD9, and test_box().

testAllRBBSphere24()

void AllRBBTest::testAllRBBSphere24 ( )

inline

Definition at line 566 of file all_rbb.C.

{ LOG_UNIT_TEST; test_sphere(1); }

References test_sphere().

testAllRBBSphere6()

void AllRBBTest::testAllRBBSphere6 ( )

inline

Definition at line 565 of file all_rbb.C.

{ LOG_UNIT_TEST; test_sphere(0); }

References test_sphere().

testAllRBBSphere96()

void AllRBBTest::testAllRBBSphere96 ( )

inline

Definition at line 567 of file all_rbb.C.

{ LOG_UNIT_TEST; test_sphere(2); }

References test_sphere().

testAllRBBTet()

void AllRBBTest::testAllRBBTet ( )

inline

Definition at line 530 of file all_rbb.C.

{ LOG_UNIT_TEST; test_box(TET4); }

References test_box(), and libMesh::TET4.

testAllRBBTet10()

void AllRBBTest::testAllRBBTet10 ( )

inline

Definition at line 531 of file all_rbb.C.

{ LOG_UNIT_TEST; test_box(TET10); }

References test_box(), and libMesh::TET10.

testAllRBBTri()

void AllRBBTest::testAllRBBTri ( )

inline

Definition at line 525 of file all_rbb.C.

{ LOG_UNIT_TEST; test_box(TRI3); }

References test_box(), and libMesh::TRI3.

testAllRBBTri6()

void AllRBBTest::testAllRBBTri6 ( )

inline

Definition at line 526 of file all_rbb.C.

{ LOG_UNIT_TEST; test_box(TRI6); }

References test_box(), and libMesh::TRI6.

testAllRBBTri6Disk10()

void AllRBBTest::testAllRBBTri6Disk10 ( )

inline

Definition at line 554 of file all_rbb.C.

{ LOG_UNIT_TEST; test_disk(0, TRI6); }

References test_disk(), and libMesh::TRI6.

testAllRBBTri6Disk160()

void AllRBBTest::testAllRBBTri6Disk160 ( )

inline

Definition at line 556 of file all_rbb.C.

{ LOG_UNIT_TEST; test_disk(2, TRI6); }

References test_disk(), and libMesh::TRI6.

testAllRBBTri6Disk40()

void AllRBBTest::testAllRBBTri6Disk40 ( )

inline

Definition at line 555 of file all_rbb.C.

{ LOG_UNIT_TEST; test_disk(1, TRI6); }

References test_disk(), and libMesh::TRI6.

testAllRBBTri6Sphere12()

void AllRBBTest::testAllRBBTri6Sphere12 ( )

inline

Definition at line 569 of file all_rbb.C.

{ LOG_UNIT_TEST; test_sphere(0, TRI6); }

References test_sphere(), and libMesh::TRI6.

testAllRBBTri6Sphere192()

void AllRBBTest::testAllRBBTri6Sphere192 ( )

inline

Definition at line 571 of file all_rbb.C.

{ LOG_UNIT_TEST; test_sphere(2, TRI6); }

References test_sphere(), and libMesh::TRI6.

testAllRBBTri6Sphere48()

void AllRBBTest::testAllRBBTri6Sphere48 ( )

inline

Definition at line 570 of file all_rbb.C.

{ LOG_UNIT_TEST; test_sphere(1, TRI6); }

References test_sphere(), and libMesh::TRI6.

---

The documentation for this class was generated from the following file:

• tests/mesh/all_rbb.C