AllSecondOrderTest Class Reference

Inheritance diagram for AllSecondOrderTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (AllSecondOrderTest)
	CPPUNIT_TEST (allSecondOrder)
	CPPUNIT_TEST (allSecondOrderRange)
	CPPUNIT_TEST (allSecondOrderDoNothing)
	CPPUNIT_TEST (allSecondOrderMixed)
	CPPUNIT_TEST (allSecondOrderMixedFixing)
	CPPUNIT_TEST (allSecondOrderMixedFixing3D)
	CPPUNIT_TEST (allCompleteOrder)
	CPPUNIT_TEST (allCompleteOrderRange)
	CPPUNIT_TEST (allCompleteOrderDoNothing)
	CPPUNIT_TEST (allCompleteOrderMixed)
	CPPUNIT_TEST (allCompleteOrderMixedFixing)
	CPPUNIT_TEST (allCompleteOrderMixedFixing3D)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	allSecondOrder ()
void	allSecondOrderRange ()
void	allSecondOrderDoNothing ()
void	allSecondOrderMixed ()
void	allSecondOrderMixedFixing ()
void	allSecondOrderMixedFixing3D ()
void	allCompleteOrder ()
void	allCompleteOrderRange ()
void	allCompleteOrderDoNothing ()
void	allCompleteOrderMixed ()
void	allCompleteOrderMixedFixing ()
void	allCompleteOrderMixedFixing3D ()

Static Public Member Functions
template<typename ConversionFunc >
static void	MixedFixingImpl (MeshBase &mesh, ConversionFunc &conv, dof_id_type expected_n_elem, dof_id_type expected_n_nodes, ElemType expected_type)

Detailed Description

Definition at line 16 of file all_second_order.C.

Member Function Documentation

allCompleteOrder()

void AllSecondOrderTest::allCompleteOrder ( )

inline

Definition at line 253 of file all_second_order.C.

References libMesh::MeshBase::all_complete_order(), libMesh::MeshBase::allow_remote_element_removal(), libMesh::MeshTools::Generation::build_square(), mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    DistributedMesh mesh(*TestCommWorld, /*dim=*/2);

    mesh.allow_remote_element_removal(false);

    MeshTools::Generation::build_square(mesh, 2, 2);

    mesh.all_complete_order();
  }

allCompleteOrderDoNothing()

void AllSecondOrderTest::allCompleteOrderDoNothing ( )

inline

Definition at line 306 of file all_second_order.C.

References libMesh::MeshBase::all_complete_order_range(), libMesh::MeshBase::allow_remote_element_removal(), libMesh::MeshTools::Generation::build_square(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::QUAD9, and TestCommWorld.

  {
    DistributedMesh mesh(*TestCommWorld, /*dim=*/2);

    mesh.allow_remote_element_removal(false);

    MeshTools::Generation::build_square(mesh,
                                        /*nx=*/2, /*ny=*/2,
                                        /*xmin=*/0., /*xmax=*/1.,
                                        /*ymin=*/0., /*ymax=*/1.,
                                        QUAD9);

    // Test that all_complete_order_range() correctly "does nothing" in
    // parallel when passed ranges of local elements. Here we should
    // hit one of the "early return" cases for this function.
    mesh.all_complete_order_range(mesh.active_local_element_ptr_range());

    // Make sure we still have the same number of elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(4), mesh.n_elem());

    // Make sure we still have the same number of nodes
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(25), mesh.n_nodes());
  }

allCompleteOrderMixed()

void AllSecondOrderTest::allCompleteOrderMixed ( )

inline

Definition at line 330 of file all_second_order.C.

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::MeshBase::all_complete_order_range(), libMesh::Elem::build(), libMesh::MeshTools::Generation::build_square(), libMesh::EDGE2, libMesh::EDGE3, libMesh::MeshBase::elem_ptr(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::Elem::n_nodes(), libMesh::Elem::n_vertices(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::point(), libMesh::QUAD9, libMesh::Elem::set_node(), TestCommWorld, and libMesh::Elem::type().

  {
    ReplicatedMesh mesh(*TestCommWorld);

    // Construct a single-element Quad9 mesh
    MeshTools::Generation::build_square(mesh,
                                        /*nx=*/1, /*ny=*/1,
                                        /*xmin=*/0., /*xmax=*/1.,
                                        /*ymin=*/0., /*ymax=*/1.,
                                        /*elem_type=*/QUAD9);

    // Pointer to the single Elem
    const Elem * elem = mesh.elem_ptr(0);

    // Amount to offset the indices of newly-added nodes by
    const unsigned int node_offset = elem->n_nodes();

    // Add an extra node above each of the original vertices
    for (dof_id_type n=0; n<elem->n_vertices(); ++n)
      mesh.add_point(mesh.point(n) + Point(0,0,1), /*id=*/node_offset + n, /*proc_id=*/0);

    // Construct Edge2 elements and attach to each vertex of Quad9
    for (dof_id_type n=0; n<elem->n_vertices(); ++n)
      {
        Elem * elem = mesh.add_elem(Elem::build(EDGE2));
        elem->set_node(0, mesh.node_ptr(n));
        elem->set_node(1, mesh.node_ptr(node_offset + n));
      }

    // Convert all elements, automatically skipping those that are
    // already complete-order.
    mesh.all_complete_order_range(mesh.element_ptr_range());

    // Make sure we still have the expected total number of elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(5), mesh.n_elem());

    // Make sure we have the correct number of nodes, 9+4+4=17
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(17), mesh.n_nodes());

    // Make sure that the type of the original Elem is unchanged
    CPPUNIT_ASSERT_EQUAL(QUAD9, elem->type());

    // Make sure that the other elements are now Edge3s
    for (dof_id_type e=1; e<5; ++e)
      CPPUNIT_ASSERT_EQUAL(EDGE3, mesh.elem_ptr(e)->type());
  }

allCompleteOrderMixedFixing()

void AllSecondOrderTest::allCompleteOrderMixedFixing ( )

inline

Definition at line 378 of file all_second_order.C.

References libMesh::MeshBase::all_complete_order_range(), libMesh::MeshTools::Generation::build_square(), mesh, TestCommWorld, libMesh::TRI3, and libMesh::TRI7.

  {
    Mesh mesh(*TestCommWorld);

    // Construct a multi-element Tri3 mesh
    MeshTools::Generation::build_square(mesh,
                                        /*nx=*/3, /*ny=*/3,
                                        /*xmin=*/0., /*xmax=*/1.,
                                        /*ymin=*/0., /*ymax=*/1.,
                                        /*elem_type=*/TRI3);

    auto conversion = [&mesh](const SimpleRange<MeshBase::element_iterator> & range) {
      mesh.all_complete_order_range(range);
    };

    MixedFixingImpl(mesh, conversion, 3*3*2, 7*7+3*3*2, TRI7);
  }

allCompleteOrderMixedFixing3D()

void AllSecondOrderTest::allCompleteOrderMixedFixing3D ( )

inline

Definition at line 396 of file all_second_order.C.

References libMesh::MeshBase::all_complete_order_range(), libMesh::MeshTools::Generation::build_cube(), mesh, libMesh::PRISM21, libMesh::PRISM6, and TestCommWorld.

  {
    Mesh mesh(*TestCommWorld);

    // Construct a multi-element Prism6 mesh
    MeshTools::Generation::build_cube(mesh,
                                      /*nx=*/3, /*ny=*/3, /*nz=*/3,
                                      /*xmin=*/0., /*xmax=*/1.,
                                      /*ymin=*/0., /*ymax=*/1.,
                                      /*zmin=*/0., /*zmax=*/1.,
                                      /*elem_type=*/PRISM6);

    auto conversion = [&mesh](const SimpleRange<MeshBase::element_iterator> & range) {
      mesh.all_complete_order_range(range);
    };

    MixedFixingImpl(mesh, conversion, 3*3*3*2, 7*7*7+3*3*2*7, PRISM21);
  }

allCompleteOrderRange()

void AllSecondOrderTest::allCompleteOrderRange ( )

inline

Definition at line 266 of file all_second_order.C.

References libMesh::MeshBase::active_subdomain_elements_ptr_range(), libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::MeshBase::all_complete_order_range(), libMesh::Elem::build(), libMesh::MeshTools::Generation::build_square(), libMesh::EDGE2, libMesh::EDGE3, libMesh::MeshBase::elem_ptr(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::point(), libMesh::QUAD4, libMesh::Elem::set_node(), libMesh::Elem::subdomain_id(), TestCommWorld, and libMesh::Elem::type().

  {
    ReplicatedMesh mesh(*TestCommWorld);

    // Construct a single-element Quad4 mesh
    MeshTools::Generation::build_square(mesh, /*nx=*/1, /*ny=*/1);

    // Add extra nodes above the four original nodes
    Point z_trans(0,0,1);
    for (dof_id_type n=0; n<4; ++n)
      mesh.add_point(mesh.point(n) + z_trans, /*id=*/4+n, /*proc_id=*/0);

    // Construct Edge2 elements attached to Quad4 at individual points
    // and in subdomain 1.
    for (dof_id_type n=0; n<4; ++n)
      {
        Elem * elem = mesh.add_elem(Elem::build(EDGE2));
        elem->set_node(0, mesh.node_ptr(n));
        elem->set_node(1, mesh.node_ptr(n+4));
        elem->subdomain_id() = 1;
      }

    // Convert only Edge2 elements (all elements in subdomain 1) to
    // higher-order.
    mesh.all_complete_order_range(mesh.active_subdomain_elements_ptr_range(1));

    // Make sure we still have the expected total number of elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(5), mesh.n_elem());

    // Make sure we added the right number of nodes
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(12), mesh.n_nodes());

    // Make sure that the type of the Quad4 is unchanged
    CPPUNIT_ASSERT_EQUAL(QUAD4, mesh.elem_ptr(0)->type());

    // Make sure that the other elements are now Edge3s
    for (dof_id_type e=1; e<5; ++e)
      CPPUNIT_ASSERT_EQUAL(EDGE3, mesh.elem_ptr(e)->type());
  }

allSecondOrder()

void AllSecondOrderTest::allSecondOrder ( )

inline

Definition at line 42 of file all_second_order.C.

References libMesh::MeshBase::all_second_order(), libMesh::MeshBase::allow_remote_element_removal(), libMesh::MeshTools::Generation::build_square(), mesh, and TestCommWorld.

  {
    LOG_UNIT_TEST;

    DistributedMesh mesh(*TestCommWorld, /*dim=*/2);

    mesh.allow_remote_element_removal(false);

    MeshTools::Generation::build_square(mesh, 2, 2);

    mesh.all_second_order();
  }

allSecondOrderDoNothing()

void AllSecondOrderTest::allSecondOrderDoNothing ( )

inline

Definition at line 96 of file all_second_order.C.

References libMesh::MeshBase::all_second_order_range(), libMesh::MeshBase::allow_remote_element_removal(), libMesh::MeshTools::Generation::build_square(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::QUAD9, and TestCommWorld.

  {
    DistributedMesh mesh(*TestCommWorld, /*dim=*/2);

    mesh.allow_remote_element_removal(false);

    MeshTools::Generation::build_square(mesh,
                                        /*nx=*/2, /*ny=*/2,
                                        /*xmin=*/0., /*xmax=*/1.,
                                        /*ymin=*/0., /*ymax=*/1.,
                                        QUAD9);

    // Test that all_second_order_range() correctly "does nothing" in
    // parallel when passed ranges of local elements. Here we should
    // hit one of the "early return" cases for this function.
    mesh.all_second_order_range(mesh.active_local_element_ptr_range(),
                                /*full_ordered=*/true);

    // Make sure we still have the same number of elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(4), mesh.n_elem());

    // Make sure we still have the same number of nodes
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(25), mesh.n_nodes());
  }

allSecondOrderMixed()

void AllSecondOrderTest::allSecondOrderMixed ( )

inline

Definition at line 121 of file all_second_order.C.

References libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::MeshBase::all_second_order_range(), libMesh::Elem::build(), libMesh::MeshTools::Generation::build_square(), libMesh::EDGE2, libMesh::EDGE3, libMesh::MeshBase::elem_ptr(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::Elem::n_nodes(), libMesh::Elem::n_vertices(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::point(), libMesh::QUAD9, libMesh::Elem::set_node(), TestCommWorld, and libMesh::Elem::type().

  {
    ReplicatedMesh mesh(*TestCommWorld);

    // Construct a single-element Quad9 mesh
    MeshTools::Generation::build_square(mesh,
                                        /*nx=*/1, /*ny=*/1,
                                        /*xmin=*/0., /*xmax=*/1.,
                                        /*ymin=*/0., /*ymax=*/1.,
                                        /*elem_type=*/QUAD9);

    // Pointer to the single Elem
    const Elem * elem = mesh.elem_ptr(0);

    // Amount to offset the indices of newly-added nodes by
    const unsigned int node_offset = elem->n_nodes();

    // Add an extra node above each of the original vertices
    for (dof_id_type n=0; n<elem->n_vertices(); ++n)
      mesh.add_point(mesh.point(n) + Point(0,0,1), /*id=*/node_offset + n, /*proc_id=*/0);

    // Construct Edge2 elements and attach to each vertex of Quad9
    for (dof_id_type n=0; n<elem->n_vertices(); ++n)
      {
        Elem * elem = mesh.add_elem(Elem::build(EDGE2));
        elem->set_node(0, mesh.node_ptr(n));
        elem->set_node(1, mesh.node_ptr(node_offset + n));
      }

    // Convert all elements to SECOND-order, automatically skipping those that are
    // already SECOND-order.
    mesh.all_second_order_range(mesh.element_ptr_range(), /*full_ordered=*/true);

    // Make sure we still have the expected total number of elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(5), mesh.n_elem());

    // Make sure we have the correct number of nodes, 9+4+4=17
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(17), mesh.n_nodes());

    // Make sure that the type of the original Elem is unchanged
    CPPUNIT_ASSERT_EQUAL(QUAD9, elem->type());

    // Make sure that the other elements are now Edge3s
    for (dof_id_type e=1; e<5; ++e)
      CPPUNIT_ASSERT_EQUAL(EDGE3, mesh.elem_ptr(e)->type());
  }

allSecondOrderMixedFixing()

void AllSecondOrderTest::allSecondOrderMixedFixing ( )

inline

Definition at line 211 of file all_second_order.C.

References libMesh::MeshBase::all_second_order_range(), libMesh::MeshBase::allow_renumbering(), libMesh::MeshTools::Generation::build_square(), mesh, libMesh::QUAD4, libMesh::QUAD9, and TestCommWorld.

  {
    Mesh mesh(*TestCommWorld);

    // Disallow renumbering so we're doing the same thing on any
    // distributed mesh partitioning
    mesh.allow_renumbering(false);

    // Construct a multi-element Quad4 mesh
    MeshTools::Generation::build_square(mesh,
                                        /*nx=*/3, /*ny=*/3,
                                        /*xmin=*/0., /*xmax=*/1.,
                                        /*ymin=*/0., /*ymax=*/1.,
                                        /*elem_type=*/QUAD4);

    auto conversion = [&mesh](const SimpleRange<MeshBase::element_iterator> & range) {
      mesh.all_second_order_range(range, /*full_ordered=*/true);
    };

    MixedFixingImpl(mesh, conversion, 3*3, 7*7, QUAD9);
  }

allSecondOrderMixedFixing3D()

void AllSecondOrderTest::allSecondOrderMixedFixing3D ( )

inline

Definition at line 233 of file all_second_order.C.

References libMesh::MeshBase::all_second_order_range(), libMesh::MeshTools::Generation::build_cube(), libMesh::HEX27, libMesh::HEX8, mesh, and TestCommWorld.

  {
    Mesh mesh(*TestCommWorld);

    // Construct a multi-element Hex8 mesh
    MeshTools::Generation::build_cube(mesh,
                                      /*nx=*/3, /*ny=*/3, /*nz=*/3,
                                      /*xmin=*/0., /*xmax=*/1.,
                                      /*ymin=*/0., /*ymax=*/1.,
                                      /*zmin=*/0., /*zmax=*/1.,
                                      /*elem_type=*/HEX8);

    auto conversion = [&mesh](const SimpleRange<MeshBase::element_iterator> & range) {
      mesh.all_second_order_range(range, /*full_ordered=*/true);
    };

    MixedFixingImpl(mesh, conversion, 3*3*3, 7*7*7, HEX27);
  }

allSecondOrderRange()

void AllSecondOrderTest::allSecondOrderRange ( )

inline

Definition at line 55 of file all_second_order.C.

References libMesh::MeshBase::active_subdomain_elements_ptr_range(), libMesh::MeshBase::add_elem(), libMesh::MeshBase::add_point(), libMesh::MeshBase::all_second_order_range(), libMesh::Elem::build(), libMesh::MeshTools::Generation::build_square(), libMesh::EDGE2, libMesh::EDGE3, libMesh::MeshBase::elem_ptr(), mesh, libMesh::MeshBase::n_elem(), libMesh::MeshBase::n_nodes(), libMesh::MeshBase::node_ptr(), libMesh::MeshBase::point(), libMesh::QUAD4, libMesh::Elem::set_node(), libMesh::Elem::subdomain_id(), TestCommWorld, and libMesh::Elem::type().

  {
    ReplicatedMesh mesh(*TestCommWorld);

    // Construct a single-element Quad4 mesh
    MeshTools::Generation::build_square(mesh, /*nx=*/1, /*ny=*/1);

    // Add extra nodes above the four original nodes
    Point z_trans(0,0,1);
    for (dof_id_type n=0; n<4; ++n)
      mesh.add_point(mesh.point(n) + z_trans, /*id=*/4+n, /*proc_id=*/0);

    // Construct Edge2 elements attached to Quad4 at individual points
    // and in subdomain 1.
    for (dof_id_type n=0; n<4; ++n)
      {
        Elem * elem = mesh.add_elem(Elem::build(EDGE2));
        elem->set_node(0, mesh.node_ptr(n));
        elem->set_node(1, mesh.node_ptr(n+4));
        elem->subdomain_id() = 1;
      }

    // Convert only Edge2 elements (all elements in subdomain 1) to
    // SECOND-order.
    mesh.all_second_order_range(mesh.active_subdomain_elements_ptr_range(1),
                                /*full_ordered=*/true);

    // Make sure we still have the expected total number of elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(5), mesh.n_elem());

    // Make sure we added the right number of nodes
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(12), mesh.n_nodes());

    // Make sure that the type of the Quad4 is unchanged
    CPPUNIT_ASSERT_EQUAL(QUAD4, mesh.elem_ptr(0)->type());

    // Make sure that the other elements are now Edge3s
    for (dof_id_type e=1; e<5; ++e)
      CPPUNIT_ASSERT_EQUAL(EDGE3, mesh.elem_ptr(e)->type());
  }

CPPUNIT_TEST() [1/12]

AllSecondOrderTest::CPPUNIT_TEST

(

allSecondOrder

)

CPPUNIT_TEST() [2/12]

AllSecondOrderTest::CPPUNIT_TEST

(

allSecondOrderRange

)

CPPUNIT_TEST() [3/12]

AllSecondOrderTest::CPPUNIT_TEST

(

allSecondOrderDoNothing

)

CPPUNIT_TEST() [4/12]

AllSecondOrderTest::CPPUNIT_TEST

(

allSecondOrderMixed

)

CPPUNIT_TEST() [5/12]

AllSecondOrderTest::CPPUNIT_TEST

(

allSecondOrderMixedFixing

)

CPPUNIT_TEST() [6/12]

AllSecondOrderTest::CPPUNIT_TEST

(

allSecondOrderMixedFixing3D

)

CPPUNIT_TEST() [7/12]

AllSecondOrderTest::CPPUNIT_TEST

(

allCompleteOrder

)

CPPUNIT_TEST() [8/12]

AllSecondOrderTest::CPPUNIT_TEST

(

allCompleteOrderRange

)

CPPUNIT_TEST() [9/12]

AllSecondOrderTest::CPPUNIT_TEST

(

allCompleteOrderDoNothing

)

CPPUNIT_TEST() [10/12]

AllSecondOrderTest::CPPUNIT_TEST

(

allCompleteOrderMixed

)

CPPUNIT_TEST() [11/12]

AllSecondOrderTest::CPPUNIT_TEST

(

allCompleteOrderMixedFixing

)

CPPUNIT_TEST() [12/12]

AllSecondOrderTest::CPPUNIT_TEST

(

allCompleteOrderMixedFixing3D

)

CPPUNIT_TEST_SUITE_END()

AllSecondOrderTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

AllSecondOrderTest::LIBMESH_CPPUNIT_TEST_SUITE

(

AllSecondOrderTest

)

MixedFixingImpl()

template<typename ConversionFunc >

static void AllSecondOrderTest::MixedFixingImpl ( MeshBase &  mesh, ConversionFunc &  conv, dof_id_type  expected_n_elem, dof_id_type  expected_n_nodes, ElemType  expected_type  )

inlinestatic

Definition at line 169 of file all_second_order.C.

References libMesh::MeshBase::allow_renumbering(), libMesh::make_range(), libMesh::MeshBase::max_elem_id(), mesh, libMesh::MeshBase::n_elem(), and libMesh::MeshBase::n_nodes().

  {
    // Convert elements to higher-order, but do so a few at a time,
    // leaving a broken mesh after initial conversions to see if it
    // will be properly fixed by subsequent conversions.

    // Keep element ids from being renumbered (DistributedMesh will do
    // this to get contiguous ranges) so we don't miss any elements
    // when we're making our ranges by id.
    mesh.allow_renumbering(false);

    // This test loop is O(N^2), because conversions can invalidate
    // iterators so we have to start over each time, but N is like 27
    // so we're okay.
    for (dof_id_type start_elem_id : make_range(mesh.max_elem_id()))
      {
        auto range_start = mesh.elements_begin();
        const auto end = mesh.elements_end();
        while (range_start != end && (*range_start)->id() < start_elem_id)
          ++range_start;
        auto range_end = range_start;
        while (range_end != end && (*range_end)->id() < start_elem_id+1+start_elem_id%2)
          ++range_end;

        conv({range_start, range_end});
      }

    // Make sure we still have the expected total number of elements
    CPPUNIT_ASSERT_EQUAL(expected_n_elem, mesh.n_elem());

    // Make sure we have the correct number of nodes, 7*7
    CPPUNIT_ASSERT_EQUAL(expected_n_nodes, mesh.n_nodes());

    // Make sure that the elements are now upgraded
    for (const auto & elem : mesh.element_ptr_range())
      CPPUNIT_ASSERT_EQUAL(expected_type, elem->type());
  }

setUp()

void AllSecondOrderTest::setUp ( )

inline

Definition at line 38 of file all_second_order.C.

{}

tearDown()

void AllSecondOrderTest::tearDown ( )

inline

Definition at line 40 of file all_second_order.C.

{}

---

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

• tests/mesh/all_second_order.C