MixedDimensionMeshTest Class Reference

Inheritance diagram for MixedDimensionMeshTest:

Public Member Functions
	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
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.

  {
    _mesh = new 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( new 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( new 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( new 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;
    }
 
    // libMesh will renumber, but we numbered according to its scheme
    // anyway. We do this because when we call uniformly_refine subsequently,
    // it's going use skip_renumber=false.
    _mesh->prepare_for_use(false /*skip_renumber*/);
  }

References libMesh::ReplicatedMesh::add_elem(), libMesh::ReplicatedMesh::add_point(), libMesh::ReplicatedMesh::node_ptr(), libMesh::MeshBase::prepare_for_use(), libMesh::MeshBase::set_mesh_dimension(), libMesh::Elem::set_node(), libMesh::Elem::subdomain_id(), and TestCommWorld.

CPPUNIT_TEST() [1/3]

MixedDimensionMeshTest::CPPUNIT_TEST

(

testDofOrdering

)

CPPUNIT_TEST() [2/3]

MixedDimensionMeshTest::CPPUNIT_TEST

(

testMesh

)

CPPUNIT_TEST() [3/3]

MixedDimensionMeshTest::CPPUNIT_TEST

(

testPointLocatorTree

)

CPPUNIT_TEST_SUITE()

MixedDimensionMeshTest::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.

CPPUNIT_TEST_SUITE_END()

MixedDimensionMeshTest::CPPUNIT_TEST_SUITE_END

(

)

setUp()

void MixedDimensionMeshTest::setUp ( )

inline

Definition at line 98 of file mixed_dim_mesh_test.C.

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

tearDown()

void MixedDimensionMeshTest::tearDown ( )

inline

Definition at line 105 of file mixed_dim_mesh_test.C.

  {
    delete _mesh;
  }

testDofOrdering()

void MixedDimensionMeshTest::testDofOrdering ( )

inline

Definition at line 138 of file mixed_dim_mesh_test.C.

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

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

testMesh()

void MixedDimensionMeshTest::testMesh ( )

inline

Definition at line 110 of file mixed_dim_mesh_test.C.

  {
    // There'd better be 3 elements
    CPPUNIT_ASSERT_EQUAL( (dof_id_type)3, _mesh->n_elem() );
 
    // There'd better be only 6 nodes
    CPPUNIT_ASSERT_EQUAL( (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() );
  }

References libMesh::MeshBase::elem_ref(), libMesh::Elem::interior_parent(), libMesh::ReplicatedMesh::n_elem(), libMesh::ReplicatedMesh::n_nodes(), and libMesh::Elem::node_id().

testPointLocatorTree()

void MixedDimensionMeshTest::testPointLocatorTree ( )

inline

Definition at line 169 of file mixed_dim_mesh_test.C.

  {
    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( (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( (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( (dof_id_type)2, interface_elem->id() );
    }
  }

References libMesh::DofObject::id(), and libMesh::MeshBase::sub_point_locator().

Member Data Documentation

_mesh

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