SlitMeshTest Class Reference

Inheritance diagram for SlitMeshTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (SlitMeshTest)
	The goal of this test is to ensure that a 2D mesh with nodes overlapping on opposite sides of an internal, "slit" edge is usable.
	CPPUNIT_TEST (testMesh)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testMesh ()

Protected Member Functions
void	build_mesh ()

Protected Attributes
std::unique_ptr< Mesh >	_mesh

Detailed Description

Definition at line 69 of file slit_mesh_test.C.

Member Function Documentation

build_mesh()

void SlitMeshTest::build_mesh ( )

inlineprotected

Definition at line 90 of file slit_mesh_test.C.

  {
    _mesh = std::make_unique<Mesh>(*TestCommWorld);
 
    // (-1,1)     (0,1)      (1,1)      (2,1)      (3,1)
    // o----------o----------o----------o----------o
    // |          |          |          |          |
    // |          |          |          |          |
    // |          |          |          |          |
    // |          |          |          |          |
    // o----------o==========8==========o----------o
    // (-1,0)     (0,0)      (1,0)      (2,0)      (3,0)
    // |          |          |          |          |
    // |          |          |          |          |
    // |          |          |          |          |
    // o----------o----------o----------o----------o
    // (-1,-1)    (0,-1)     (1,-1)     (2,-1)     (3,-1)
 
    _mesh->set_mesh_dimension(2);
 
    _mesh->add_point( Point(0.0, 0.0), 0 );
    _mesh->add_point( Point(1.0, 0.0), 1 );
    _mesh->add_point( Point(1.0, 1.0), 2 );
    _mesh->add_point( Point(0.0, 1.0), 3 );
    _mesh->add_point( Point(0.0,-1.0), 4 );
    _mesh->add_point( Point(1.0,-1.0), 5 );
    _mesh->add_point( Point(1.0, 0.0), 6 ); // Doubled!
    _mesh->add_point( Point(2.0, 0.0), 7 );
    _mesh->add_point( Point(2.0, 1.0), 8 );
    _mesh->add_point( Point(2.0,-1.0), 9 );
    _mesh->add_point( Point(-1.0,-1.0), 10);
    _mesh->add_point( Point(-1.0, 0.0), 11);
    _mesh->add_point( Point(-1.0, 1.0), 12);
    _mesh->add_point( Point(3.0,-1.0), 13);
    _mesh->add_point( Point(3.0, 0.0), 14);
    _mesh->add_point( Point(3.0, 1.0), 15);
 
    {
      Elem * elem_top_left = _mesh->add_elem(Elem::build_with_id(QUAD4, 0));
      elem_top_left->set_node(0, _mesh->node_ptr(0));
      elem_top_left->set_node(1, _mesh->node_ptr(1));
      elem_top_left->set_node(2, _mesh->node_ptr(2));
      elem_top_left->set_node(3, _mesh->node_ptr(3));
 
      Elem * elem_bottom_left = _mesh->add_elem(Elem::build_with_id(QUAD4, 1));
      elem_bottom_left->set_node(0, _mesh->node_ptr(4));
      elem_bottom_left->set_node(1, _mesh->node_ptr(5));
      elem_bottom_left->set_node(2, _mesh->node_ptr(6));
      elem_bottom_left->set_node(3, _mesh->node_ptr(0));
 
      Elem * elem_top_right = _mesh->add_elem(Elem::build_with_id(QUAD4, 2));
      elem_top_right->set_node(0, _mesh->node_ptr(1));
      elem_top_right->set_node(1, _mesh->node_ptr(7));
      elem_top_right->set_node(2, _mesh->node_ptr(8));
      elem_top_right->set_node(3, _mesh->node_ptr(2));
 
      Elem * elem_bottom_right = _mesh->add_elem(Elem::build_with_id(QUAD4, 3));
      elem_bottom_right->set_node(0, _mesh->node_ptr(5));
      elem_bottom_right->set_node(1, _mesh->node_ptr(9));
      elem_bottom_right->set_node(2, _mesh->node_ptr(7));
      elem_bottom_right->set_node(3, _mesh->node_ptr(6));
 
      Elem * elem_top_leftleft = _mesh->add_elem(Elem::build_with_id(QUAD4, 4));
      elem_top_leftleft->set_node(0, _mesh->node_ptr(11));
      elem_top_leftleft->set_node(1, _mesh->node_ptr(0));
      elem_top_leftleft->set_node(2, _mesh->node_ptr(3));
      elem_top_leftleft->set_node(3, _mesh->node_ptr(12));
 
      Elem * elem_bottom_leftleft = _mesh->add_elem(Elem::build_with_id(QUAD4, 5));
      elem_bottom_leftleft->set_node(0, _mesh->node_ptr(10));
      elem_bottom_leftleft->set_node(1, _mesh->node_ptr(4));
      elem_bottom_leftleft->set_node(2, _mesh->node_ptr(0));
      elem_bottom_leftleft->set_node(3, _mesh->node_ptr(11));
 
      Elem * elem_top_rightright = _mesh->add_elem(Elem::build_with_id(QUAD4, 6));
      elem_top_rightright->set_node(0, _mesh->node_ptr(7));
      elem_top_rightright->set_node(1, _mesh->node_ptr(14));
      elem_top_rightright->set_node(2, _mesh->node_ptr(15));
      elem_top_rightright->set_node(3, _mesh->node_ptr(8));
 
      Elem * elem_bottom_rightright = _mesh->add_elem(Elem::build_with_id(QUAD4, 7));
      elem_bottom_rightright->set_node(0, _mesh->node_ptr(9));
      elem_bottom_rightright->set_node(1, _mesh->node_ptr(13));
      elem_bottom_rightright->set_node(2, _mesh->node_ptr(14));
      elem_bottom_rightright->set_node(3, _mesh->node_ptr(7));
    }
 
    // libMesh shouldn't renumber, or our based-on-initial-id
    // assertions later may fail.
    _mesh->allow_renumbering(false);
 
    _mesh->prepare_for_use();
  }

References _mesh, libMesh::Elem::build_with_id(), libMesh::QUAD4, libMesh::Elem::set_node(), and TestCommWorld.

Referenced by setUp(), SlitMeshRefinedMeshTest::setUp(), and SlitMeshRefinedSystemTest::setUp().

CPPUNIT_TEST()

SlitMeshTest::CPPUNIT_TEST

(

testMesh

)

CPPUNIT_TEST_SUITE_END()

SlitMeshTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

SlitMeshTest::LIBMESH_CPPUNIT_TEST_SUITE

(

SlitMeshTest

)

The goal of this test is to ensure that a 2D mesh with nodes overlapping on opposite sides of an internal, "slit" edge is usable.

The mesh has to be connected at more than one node on each side of the slit, however, to ensure that we can find point neighbors of each node.

setUp()

void SlitMeshTest::setUp ( )

inline

Definition at line 185 of file slit_mesh_test.C.

  {
#if LIBMESH_DIM > 1
    this->build_mesh();
#endif
  }

References build_mesh().

tearDown()

void SlitMeshTest::tearDown ( )

inline

Definition at line 192 of file slit_mesh_test.C.

{}

testMesh()

void SlitMeshTest::testMesh ( )

inline

Definition at line 194 of file slit_mesh_test.C.

  {
    LOG_UNIT_TEST;
 
    // There'd better be 8 elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(8), _mesh->n_elem());
 
    // There'd better still be a full 16 nodes
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(16), _mesh->n_nodes());
 
    /* The middle nodes should still be distinct between the top and
     * bottom elements */
    if (_mesh->query_elem_ptr(0) && _mesh->query_elem_ptr(1))
      CPPUNIT_ASSERT( _mesh->elem_ref(0).node_id(1) != _mesh->elem_ref(1).node_id(2) );
    if (_mesh->query_elem_ptr(2) && _mesh->query_elem_ptr(3))
      CPPUNIT_ASSERT( _mesh->elem_ref(2).node_id(0) != _mesh->elem_ref(3).node_id(3) );
 
    /* The middle nodes should still be shared between left and right
     * elements on top and bottom */
    if (_mesh->query_elem_ptr(0) && _mesh->query_elem_ptr(2))
      CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(0).node_id(1),
                            _mesh->elem_ref(2).node_id(0) );
    if (_mesh->query_elem_ptr(1) && _mesh->query_elem_ptr(3))
      CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(1).node_id(2),
                            _mesh->elem_ref(3).node_id(3) );
  }

References _mesh.

Member Data Documentation

_mesh

std::unique_ptr<Mesh> SlitMeshTest::_mesh

protected

Definition at line 88 of file slit_mesh_test.C.

Referenced by build_mesh(), SlitMeshRefinedSystemTest::setUp(), testMesh(), SlitMeshRefinedMeshTest::testMesh(), SlitMeshRefinedSystemTest::testMesh(), SlitMeshRefinedSystemTest::testRestart(), and SlitMeshRefinedSystemTest::testSystem().

---

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

• tests/mesh/slit_mesh_test.C