BoundaryMesh0DTest Class Reference

Inheritance diagram for BoundaryMesh0DTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (BoundaryMesh0DTest)
	The goal of this test is to ensure that a 1D mesh generates boundary meshes correctly. More...
	CPPUNIT_TEST (testMesh)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	testMesh ()
void	testBoundarySerialization ()
void	sanityCheck ()

Protected Member Functions
void	build_mesh ()
void	sync_and_test_meshes ()

Protected Attributes
std::unique_ptr< UnstructuredMesh >	_mesh
std::unique_ptr< UnstructuredMesh >	_replicated_boundary_mesh
std::unique_ptr< UnstructuredMesh >	_distributed_boundary_mesh
std::unique_ptr< UnstructuredMesh >	_interior_node_mesh

Detailed Description

Definition at line 81 of file boundary_mesh.C.

Member Function Documentation

build_mesh()

void BoundaryMesh0DTest::build_mesh ( )

inlineprotected

Definition at line 102 of file boundary_mesh.C.

References libMesh::BoundaryInfo::add_side(), libMesh::MeshTools::Generation::build_line(), and libMesh::EDGE3.

  {
    _mesh = std::make_unique<Mesh>(*TestCommWorld);
    _replicated_boundary_mesh = std::make_unique<ReplicatedMesh>(*TestCommWorld);
    _distributed_boundary_mesh = std::make_unique<DistributedMesh>(*TestCommWorld);
    _interior_node_mesh = std::make_unique<Mesh>(*TestCommWorld);

    MeshTools::Generation::build_line(*_mesh, 3,
                                        0.2, 0.8, EDGE3);

    static constexpr boundary_id_type bid_int = 2;

    // Add an interior boundary too
    BoundaryInfo & bi = _mesh->get_boundary_info();
    for (auto & elem : _mesh->active_element_ptr_range())
      {
        const Point c = elem->vertex_average();
        if (c(0) > 0.6)
          bi.add_side(elem, 0, bid_int);
      }

    // We'll need to skip most repartitioning with DistributedMesh for
    // now; otherwise the boundary meshes' interior parents might get
    // shuffled off to different processors.
    if (!_mesh->is_serial())
      {
        _mesh->skip_noncritical_partitioning(true);
        _replicated_boundary_mesh->skip_noncritical_partitioning(true);
        _distributed_boundary_mesh->skip_noncritical_partitioning(true);
      }
  }

CPPUNIT_TEST()

BoundaryMesh0DTest::CPPUNIT_TEST

(

testMesh

)

CPPUNIT_TEST_SUITE_END()

BoundaryMesh0DTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

BoundaryMesh0DTest::LIBMESH_CPPUNIT_TEST_SUITE

(

BoundaryMesh0DTest

)

The goal of this test is to ensure that a 1D mesh generates boundary meshes correctly.

sanityCheck()

void BoundaryMesh0DTest::sanityCheck ( )

inline

Definition at line 228 of file boundary_mesh.C.

References libMesh::EDGE3, and libMesh::NODEELEM.

  {
    sanity_check_mesh(*_mesh, NODEELEM, EDGE3, true);

    sanity_check_mesh(*_replicated_boundary_mesh, NODEELEM, EDGE3, false);
    sanity_check_mesh(*_distributed_boundary_mesh, NODEELEM, EDGE3, false);
    sanity_check_mesh(*_interior_node_mesh, NODEELEM, EDGE3, false);
  }

setUp()

void BoundaryMesh0DTest::setUp ( )

inline

Definition at line 165 of file boundary_mesh.C.

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

sync_and_test_meshes()

void BoundaryMesh0DTest::sync_and_test_meshes ( )

inlineprotected

Definition at line 134 of file boundary_mesh.C.

  {
    // Get the border of the line
    const std::set<boundary_id_type> exterior_boundaries {0, 1};

    _mesh->get_boundary_info().sync(exterior_boundaries,
                                    *_replicated_boundary_mesh);
    check_parent_side_index_tag(*_replicated_boundary_mesh);

    _mesh->get_boundary_info().sync(exterior_boundaries,
                                    *_distributed_boundary_mesh);
    check_parent_side_index_tag(*_distributed_boundary_mesh);

    const std::set<boundary_id_type> interior_boundaries {2};
    _mesh->get_boundary_info().sync(interior_boundaries,
                                    *_interior_node_mesh);
    check_parent_side_index_tag(*_interior_node_mesh);

    // Add the right side of the square to the square; this should
    // make it a mixed dimension mesh. We skip storing the parent
    // side ids (which is the default) since they are not needed
    // in this particular test.
    std::set<boundary_id_type> right_id;
    right_id.insert(1);

    _mesh->get_boundary_info().add_elements
      (right_id, *_mesh, /*store_parent_side_ids=*/false);
    _mesh->prepare_for_use();
  }

testBoundarySerialization()

void BoundaryMesh0DTest::testBoundarySerialization ( )

inline

Definition at line 207 of file boundary_mesh.C.

  {
    LOG_UNIT_TEST;

    MeshSerializer internal_serializer(*_distributed_boundary_mesh);

    // There'd better be 2 elements on the exterior boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(2),
                         _replicated_boundary_mesh->n_elem());
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(2),
                         _distributed_boundary_mesh->n_elem());

    // There'd better be 2 nodes on the exterior boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(2),
                         _replicated_boundary_mesh->n_nodes());
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(2),
                         _distributed_boundary_mesh->n_nodes());

    this->sanityCheck();
  }

testMesh()

void BoundaryMesh0DTest::testMesh ( )

inline

Definition at line 173 of file boundary_mesh.C.

  {
    LOG_UNIT_TEST;

    // There'd better be 3 + 1 elements in the interior plus right
    // boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(4),
                         _mesh->n_elem());

    // There'd better be 7 nodes in the interior
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(7),
                         _mesh->n_nodes());

    // There'd better be 2 elements on the exterior boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(2),
                         _replicated_boundary_mesh->n_elem());
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(2),
                         _distributed_boundary_mesh->n_elem());

    // There'd better be 2 nodes on the exterior boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(2),
                         _replicated_boundary_mesh->n_nodes());
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(2),
                         _distributed_boundary_mesh->n_nodes());

    // There'd better be 1 nodeelem on the interior boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(1),
                         _interior_node_mesh->n_elem());
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(1),
                         _interior_node_mesh->n_nodes());

    this->sanityCheck();
  }

Member Data Documentation

_distributed_boundary_mesh

std::unique_ptr<UnstructuredMesh> BoundaryMesh0DTest::_distributed_boundary_mesh

protected

Definition at line 99 of file boundary_mesh.C.

_interior_node_mesh

std::unique_ptr<UnstructuredMesh> BoundaryMesh0DTest::_interior_node_mesh

protected

Definition at line 100 of file boundary_mesh.C.

_mesh

std::unique_ptr<UnstructuredMesh> BoundaryMesh0DTest::_mesh

protected

Definition at line 97 of file boundary_mesh.C.

_replicated_boundary_mesh

std::unique_ptr<UnstructuredMesh> BoundaryMesh0DTest::_replicated_boundary_mesh

protected

Definition at line 98 of file boundary_mesh.C.

---

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

• tests/mesh/boundary_mesh.C