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). More...
	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_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 ()

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)

Detailed Description

Definition at line 17 of file all_rbb.C.

Member Function Documentation

CPPUNIT_TEST() [1/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBNodeElem

)

CPPUNIT_TEST() [2/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBEdge

)

CPPUNIT_TEST() [3/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBEdge3

)

CPPUNIT_TEST() [4/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTri

)

CPPUNIT_TEST() [5/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTri6

)

CPPUNIT_TEST() [6/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBQuad

)

CPPUNIT_TEST() [7/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBQuad8

)

CPPUNIT_TEST() [8/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBQuad9

)

CPPUNIT_TEST() [9/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBCircle4

)

CPPUNIT_TEST() [10/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBCircle8

)

CPPUNIT_TEST() [11/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBCircle16

)

CPPUNIT_TEST() [12/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBDisk5

)

CPPUNIT_TEST() [13/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBDisk20

)

CPPUNIT_TEST() [14/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBDisk80

)

CPPUNIT_TEST() [15/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTri6Disk10

)

CPPUNIT_TEST() [16/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTri6Disk40

)

CPPUNIT_TEST() [17/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTri6Disk160

)

CPPUNIT_TEST() [18/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTet

)

CPPUNIT_TEST() [19/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBTet10

)

CPPUNIT_TEST() [20/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBHex

)

CPPUNIT_TEST() [21/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBHex20

)

CPPUNIT_TEST() [22/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBHex27

)

CPPUNIT_TEST() [23/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBCylinder10

)

CPPUNIT_TEST() [24/24]

AllRBBTest::CPPUNIT_TEST

(

testAllRBBCylinder80

)

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 360 of file all_rbb.C.

{}

tearDown()

void AllRBBTest::tearDown ( )

inline

Definition at line 362 of file all_rbb.C.

{}

test_box()

void AllRBBTest::test_box ( ElemType  elem_type )

inlineprotected

Definition at line 82 of file all_rbb.C.

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().

  {
    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);
    }
  }

test_circle()

void AllRBBTest::test_circle ( unsigned int  n_refinements )

inlineprotected

Definition at line 140 of file all_rbb.C.

References libMesh::MeshTools::Modification::all_rbb(), libMesh::MeshTools::Generation::build_sphere(), 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, and libMesh::MeshTools::volume().

  {
    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_elem(), n_edges);

    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);
  }

test_cylinder()

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

inlineprotected

Definition at line 269 of file all_rbb.C.

References libMesh::MeshTools::Modification::all_rbb(), libMesh::QBase::build(), libMesh::Elem::build(), libMesh::MeshTools::Generation::build_extrusion(), libMesh::MeshTools::Generation::build_sphere(), libMesh::make_range(), libMesh::FEMap::map(), mesh, libMesh::MeshTools::n_elem(), 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().

  {
    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);
  }

test_disk()

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

inlineprotected

Definition at line 204 of file all_rbb.C.

References libMesh::MeshTools::Modification::all_rbb(), libMesh::MeshTools::Generation::build_sphere(), libMesh::libmesh_ignore(), libMesh::make_range(), libMesh::FEMap::map(), mesh, libMesh::MeshTools::n_elem(), 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().

  {
    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);
  }

testAllRBBCircle16()

void AllRBBTest::testAllRBBCircle16 ( )

inline

Definition at line 388 of file all_rbb.C.

{ LOG_UNIT_TEST; test_circle(2); }

testAllRBBCircle4()

void AllRBBTest::testAllRBBCircle4 ( )

inline

Definition at line 386 of file all_rbb.C.

{ LOG_UNIT_TEST; test_circle(0); }

testAllRBBCircle8()

void AllRBBTest::testAllRBBCircle8 ( )

inline

Definition at line 387 of file all_rbb.C.

{ LOG_UNIT_TEST; test_circle(1); }

testAllRBBCylinder10()

void AllRBBTest::testAllRBBCylinder10 ( )

inline

Definition at line 402 of file all_rbb.C.

{ LOG_UNIT_TEST; test_cylinder(0); }

testAllRBBCylinder80()

void AllRBBTest::testAllRBBCylinder80 ( )

inline

Definition at line 403 of file all_rbb.C.

{ LOG_UNIT_TEST; test_cylinder(1); }

testAllRBBDisk20()

void AllRBBTest::testAllRBBDisk20 ( )

inline

Definition at line 393 of file all_rbb.C.

{ LOG_UNIT_TEST; test_disk(1); }

testAllRBBDisk5()

void AllRBBTest::testAllRBBDisk5 ( )

inline

Definition at line 392 of file all_rbb.C.

{ LOG_UNIT_TEST; test_disk(0); }

testAllRBBDisk80()

void AllRBBTest::testAllRBBDisk80 ( )

inline

Definition at line 394 of file all_rbb.C.

{ LOG_UNIT_TEST; test_disk(2); }

testAllRBBEdge()

void AllRBBTest::testAllRBBEdge ( )

inline

Definition at line 365 of file all_rbb.C.

References libMesh::EDGE2.

{ LOG_UNIT_TEST; test_box(EDGE2); }

testAllRBBEdge3()

void AllRBBTest::testAllRBBEdge3 ( )

inline

Definition at line 366 of file all_rbb.C.

References libMesh::EDGE3.

{ LOG_UNIT_TEST; test_box(EDGE3); }

testAllRBBHex()

void AllRBBTest::testAllRBBHex ( )

inline

Definition at line 374 of file all_rbb.C.

References libMesh::HEX8.

{ LOG_UNIT_TEST; test_box(HEX8); }

testAllRBBHex20()

void AllRBBTest::testAllRBBHex20 ( )

inline

Definition at line 375 of file all_rbb.C.

References libMesh::HEX20.

{ LOG_UNIT_TEST; test_box(HEX20); }

testAllRBBHex27()

void AllRBBTest::testAllRBBHex27 ( )

inline

Definition at line 376 of file all_rbb.C.

References libMesh::HEX27.

{ LOG_UNIT_TEST; test_box(HEX27); }

testAllRBBNodeElem()

void AllRBBTest::testAllRBBNodeElem ( )

inline

Definition at line 364 of file all_rbb.C.

References libMesh::NODEELEM.

{ LOG_UNIT_TEST; test_box(NODEELEM); }

testAllRBBQuad()

void AllRBBTest::testAllRBBQuad ( )

inline

Definition at line 369 of file all_rbb.C.

References libMesh::QUAD4.

{ LOG_UNIT_TEST; test_box(QUAD4); }

testAllRBBQuad8()

void AllRBBTest::testAllRBBQuad8 ( )

inline

Definition at line 370 of file all_rbb.C.

References libMesh::QUAD8.

{ LOG_UNIT_TEST; test_box(QUAD8); }

testAllRBBQuad9()

void AllRBBTest::testAllRBBQuad9 ( )

inline

Definition at line 371 of file all_rbb.C.

References libMesh::QUAD9.

{ LOG_UNIT_TEST; test_box(QUAD9); }

testAllRBBTet()

void AllRBBTest::testAllRBBTet ( )

inline

Definition at line 372 of file all_rbb.C.

References libMesh::TET4.

{ LOG_UNIT_TEST; test_box(TET4); }

testAllRBBTet10()

void AllRBBTest::testAllRBBTet10 ( )

inline

Definition at line 373 of file all_rbb.C.

References libMesh::TET10.

{ LOG_UNIT_TEST; test_box(TET10); }

testAllRBBTri()

void AllRBBTest::testAllRBBTri ( )

inline

Definition at line 367 of file all_rbb.C.

References libMesh::TRI3.

{ LOG_UNIT_TEST; test_box(TRI3); }

testAllRBBTri6()

void AllRBBTest::testAllRBBTri6 ( )

inline

Definition at line 368 of file all_rbb.C.

References libMesh::TRI6.

{ LOG_UNIT_TEST; test_box(TRI6); }

testAllRBBTri6Disk10()

void AllRBBTest::testAllRBBTri6Disk10 ( )

inline

Definition at line 396 of file all_rbb.C.

References libMesh::TRI6.

{ LOG_UNIT_TEST; test_disk(0, TRI6); }

testAllRBBTri6Disk160()

void AllRBBTest::testAllRBBTri6Disk160 ( )

inline

Definition at line 398 of file all_rbb.C.

References libMesh::TRI6.

{ LOG_UNIT_TEST; test_disk(2, TRI6); }

testAllRBBTri6Disk40()

void AllRBBTest::testAllRBBTri6Disk40 ( )

inline

Definition at line 397 of file all_rbb.C.

References libMesh::TRI6.

{ LOG_UNIT_TEST; test_disk(1, TRI6); }

---

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

• tests/mesh/all_rbb.C