MixedDimensionMeshTest Class Reference

Inheritance diagram for MixedDimensionMeshTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (MixedDimensionMeshTest)
	The goal of this test is to ensure that a 2D mesh with 1D elements overlapping on the edge is consistent. More...
	CPPUNIT_TEST (testMesh)
	CPPUNIT_TEST (testDofOrdering)
	CPPUNIT_TEST (testPointLocatorTree)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testMesh ()
void	testDofOrdering ()
void	testPointLocatorTree ()

Protected Member Functions
void	build_mesh ()

Protected Attributes
std::unique_ptr< ReplicatedMesh >	_mesh

Detailed Description

Definition at line 18 of file mixed_dim_mesh_test.C.

Member Function Documentation

build_mesh()

void MixedDimensionMeshTest::build_mesh ( )

inlineprotected

Definition at line 41 of file mixed_dim_mesh_test.C.

References libMesh::Elem::build(), libMesh::EDGE2, libMesh::QUAD4, libMesh::Elem::set_node(), and libMesh::Elem::subdomain_id().

  {
    _mesh = std::make_unique<ReplicatedMesh>(*TestCommWorld);

    // (0,1)           (1,1)
    // x---------------x
    // |               |
    // |               |
    // |               |
    // |               |
    // |               |
    // x---------------x
    // (0,0)           (1,0)
    // |               |
    // |               |
    // |               |
    // |               |
    // x---------------x
    // (0,-1)          (1,-1)

    _mesh->set_mesh_dimension(2);

    _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), 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, 0.0), 0 );

    {
      Elem * elem_top = _mesh->add_elem(Elem::build(QUAD4));
      elem_top->set_node(0, _mesh->node_ptr(0));
      elem_top->set_node(1, _mesh->node_ptr(1));
      elem_top->set_node(2, _mesh->node_ptr(2));
      elem_top->set_node(3, _mesh->node_ptr(3));

      Elem * elem_bottom = _mesh->add_elem(Elem::build(QUAD4));
      elem_bottom->set_node(0, _mesh->node_ptr(4));
      elem_bottom->set_node(1, _mesh->node_ptr(5));
      elem_bottom->set_node(2, _mesh->node_ptr(1));
      elem_bottom->set_node(3, _mesh->node_ptr(0));

      Elem * edge = _mesh->add_elem(Elem::build(EDGE2));
      edge->set_node(0, _mesh->node_ptr(0));
      edge->set_node(1, _mesh->node_ptr(1));

      // 2D elements will have subdomain id 0, this one will have 1
      edge->subdomain_id() = 1;
    }

    _mesh->allow_renumbering(true);
    _mesh->prepare_for_use();
  }

CPPUNIT_TEST() [1/3]

MixedDimensionMeshTest::CPPUNIT_TEST

(

testMesh

)

CPPUNIT_TEST() [2/3]

MixedDimensionMeshTest::CPPUNIT_TEST

(

testDofOrdering

)

CPPUNIT_TEST() [3/3]

MixedDimensionMeshTest::CPPUNIT_TEST

(

testPointLocatorTree

)

CPPUNIT_TEST_SUITE_END()

MixedDimensionMeshTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

MixedDimensionMeshTest::LIBMESH_CPPUNIT_TEST_SUITE

(

MixedDimensionMeshTest

)

The goal of this test is to ensure that a 2D mesh with 1D elements overlapping on the edge is consistent.

That is, they share the same global node numbers and the same dof numbers for a variable.

setUp()

void MixedDimensionMeshTest::setUp ( )

inline

Definition at line 96 of file mixed_dim_mesh_test.C.

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

tearDown()

void MixedDimensionMeshTest::tearDown ( )

inline

Definition at line 103 of file mixed_dim_mesh_test.C.

{}

testDofOrdering()

void MixedDimensionMeshTest::testDofOrdering ( )

inline

Definition at line 135 of file mixed_dim_mesh_test.C.

References libMesh::EquationSystems::add_system(), libMesh::DofMap::dof_indices(), libMesh::FIRST, libMesh::EquationSystems::get_system(), and libMesh::EquationSystems::init().

  {
    LOG_UNIT_TEST;

    EquationSystems es(*_mesh);
    es.add_system<LinearImplicitSystem>("TestDofSystem");
    es.get_system("TestDofSystem").add_variable("u",FIRST);
    es.init();

    DofMap& dof_map = es.get_system("TestDofSystem").get_dof_map();

    std::vector<dof_id_type> top_quad_dof_indices, bottom_quad_dof_indices, edge_dof_indices;

    dof_map.dof_indices( _mesh->elem_ptr(0), top_quad_dof_indices );
    dof_map.dof_indices( _mesh->elem_ptr(1), bottom_quad_dof_indices );
    dof_map.dof_indices( _mesh->elem_ptr(2), edge_dof_indices );

    /* The dofs for the EDGE2 element should be the same
       as the bottom edge of the top QUAD4 dofs */
    CPPUNIT_ASSERT_EQUAL( edge_dof_indices[0], top_quad_dof_indices[0] );
    CPPUNIT_ASSERT_EQUAL( edge_dof_indices[1], top_quad_dof_indices[1] );

    /* The dofs for the EDGE2 element should be the same
       as the top edge of the bottom QUAD4 dofs */
    CPPUNIT_ASSERT_EQUAL( edge_dof_indices[0], bottom_quad_dof_indices[3] );
    CPPUNIT_ASSERT_EQUAL( edge_dof_indices[1], bottom_quad_dof_indices[2] );

    /* The nodes for the bottom edge of the top QUAD4 element should have
       the same global ids as the top edge of the bottom QUAD4 element */
    CPPUNIT_ASSERT_EQUAL( top_quad_dof_indices[0], bottom_quad_dof_indices[3] );
    CPPUNIT_ASSERT_EQUAL( top_quad_dof_indices[1], bottom_quad_dof_indices[2] );
  }

testMesh()

void MixedDimensionMeshTest::testMesh ( )

inline

Definition at line 105 of file mixed_dim_mesh_test.C.

  {
    LOG_UNIT_TEST;

    // There'd better be 3 elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(3), _mesh->n_elem());

    // There'd better be only 6 nodes
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(6), _mesh->n_nodes());

    /* The nodes for the EDGE2 element should have the same global ids
       as the bottom edge of the top QUAD4 element */
    CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(2).node_id(0), _mesh->elem_ref(0).node_id(0) );
    CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(2).node_id(1), _mesh->elem_ref(0).node_id(1) );

    /* The nodes for the EDGE2 element should have the same global ids
       as the top edge of the bottom QUAD4 element */
    CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(2).node_id(0), _mesh->elem_ref(1).node_id(3) );
    CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(2).node_id(1), _mesh->elem_ref(1).node_id(2) );

    /* The nodes for the bottom edge of the top QUAD4 element should have
       the same global ids as the top edge of the bottom QUAD4 element */
    CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(0).node_id(0), _mesh->elem_ref(1).node_id(3) );
    CPPUNIT_ASSERT_EQUAL( _mesh->elem_ref(0).node_id(1), _mesh->elem_ref(1).node_id(2) );

    // We didn't set an interior_parent on the edge element, so it
    // should default to NULL
    CPPUNIT_ASSERT( _mesh->elem_ref(2).interior_parent() );
  }

testPointLocatorTree()

void MixedDimensionMeshTest::testPointLocatorTree ( )

inline

Definition at line 168 of file mixed_dim_mesh_test.C.

References libMesh::DofObject::id().

  {
    LOG_UNIT_TEST;

    std::unique_ptr<PointLocatorBase> locator = _mesh->sub_point_locator();

    Point top_point(0.5, 0.5);
    const Elem* top_elem = (*locator)(top_point);
    CPPUNIT_ASSERT(top_elem);

    // We should have gotten back the top quad
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(0), top_elem->id());

    Point bottom_point(0.5, -0.5);
    const Elem* bottom_elem = (*locator)(bottom_point);
    CPPUNIT_ASSERT(bottom_elem);

    // We should have gotten back the bottom quad
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(1), bottom_elem->id());

    // Test getting back the edge
    {
      std::set<subdomain_id_type> subdomain_id; subdomain_id.insert(1);
      Point interface_point( 0.5, 0.0 );
      const Elem* interface_elem = (*locator)(interface_point, &subdomain_id);
      CPPUNIT_ASSERT(interface_elem);

      // We should have gotten back the overlapping edge element
      CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(2), interface_elem->id());
    }
  }

Member Data Documentation

_mesh

std::unique_ptr<ReplicatedMesh> MixedDimensionMeshTest::_mesh

protected

Definition at line 39 of file mixed_dim_mesh_test.C.

---

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

• tests/mesh/mixed_dim_mesh_test.C