BoundaryOfRefinedMeshTest Class Reference

Inheritance diagram for BoundaryOfRefinedMeshTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (BoundaryOfRefinedMeshTest)
	The goal of this test is the same as the previous, but now we do a uniform refinement before synchronizing to the boundary mesh rather than after. More...
	CPPUNIT_TEST (testMesh)
	CPPUNIT_TEST (testBoundarySerialization)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	testMesh ()
void	testBoundarySerialization ()
	LIBMESH_CPPUNIT_TEST_SUITE (BoundaryMeshTest)
	The goal of this test is to ensure that a 2D mesh generates boundary meshes correctly. More...
void	sanityCheck ()

Protected Member Functions
void	build_mesh ()
void	sync_and_test_meshes ()

Protected Attributes
std::unique_ptr< UnstructuredMesh >	_mesh
std::unique_ptr< UnstructuredMesh >	_multi_boundary_mesh
std::unique_ptr< UnstructuredMesh >	_exterior_boundary_mesh
std::unique_ptr< UnstructuredMesh >	_left_boundary_mesh
std::unique_ptr< UnstructuredMesh >	_internal_boundary_mesh

Static Protected Attributes
static constexpr boundary_id_type	bid1 = 5
static constexpr boundary_id_type	bid2 = 6

Detailed Description

Definition at line 646 of file boundary_mesh.C.

Member Function Documentation

build_mesh()

void BoundaryMeshTest::build_mesh ( )

inlineprotectedinherited

Definition at line 269 of file boundary_mesh.C.

References libMesh::BoundaryInfo::add_side(), libMesh::MeshTools::Generation::build_square(), and libMesh::QUAD9.

  {
    _mesh = std::make_unique<Mesh>(*TestCommWorld);
    _multi_boundary_mesh = std::make_unique<Mesh>(*TestCommWorld);
    _exterior_boundary_mesh = std::make_unique<Mesh>(*TestCommWorld);

    // We want to test Distributed->Replicated sync; this does that in
    // some builds
    _left_boundary_mesh = std::make_unique<ReplicatedMesh>(*TestCommWorld);

    // We want to test Replicated->Distributed sync; this does that in
    // other builds
    _internal_boundary_mesh = std::make_unique<DistributedMesh>(*TestCommWorld);

    MeshTools::Generation::build_square(*_mesh, 3, 5,
                                        0.2, 0.8, 0.2, 0.7, QUAD9);

    // 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);
        _left_boundary_mesh->skip_noncritical_partitioning(true);
        _multi_boundary_mesh->skip_noncritical_partitioning(true);
        _exterior_boundary_mesh->skip_noncritical_partitioning(true);
        _internal_boundary_mesh->skip_noncritical_partitioning(true);
      }

    // Set subdomain ids for specific elements. This allows us to later
    // build an internal sideset with respect to a given
    // subdomain. The element subdomains look like:
    // ___________________
    // |  2  |  2  |  2  |
    // |_____|_____|_____|
    // |  2  |  2  |  2  |
    // |_____|_____|_____|
    // |  2  |  2  |  2  |
    // |_____|_____|_____|
    // |  1  |  1  |  2  |
    // |_____|_____|_____|
    // |  1  |  1  |  2  |
    // |_____|_____|_____|
    //
    // and we will create an internal sideset along the border between
    // subdomains 1 and 2.

    for (auto & elem : _mesh->active_element_ptr_range())
      {
        const Point c = elem->vertex_average();
        if (c(0) < 0.6 && c(1) < 0.4)
          elem->subdomain_id() = 1;
        else
          elem->subdomain_id() = 2;
      }

    // To test the "relative to" feature, we add the same sides to the
    // same sideset twice, from elements in subdomain 2 the second
    // time.  These should not show up in the BoundaryMesh, i.e. there
    // should not be overlapped elems in the BoundaryMesh.
    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 && c(1) < 0.4)
          {
            if (c(0) > 0.4)
              bi.add_side(elem, 1, bid1);
            if (c(1) > 0.3)
              bi.add_side(elem, 2, bid1);
          }
        else
          {
            if (c(0) < 0.75 && c(1) < 0.4)
              bi.add_side(elem, 3, bid2);
            if (c(0) < 0.6 && c(1) < 0.5)
              bi.add_side(elem, 0, bid2);
          }
      }
  }

CPPUNIT_TEST() [1/2]

BoundaryOfRefinedMeshTest::CPPUNIT_TEST

(

testMesh

)

CPPUNIT_TEST() [2/2]

BoundaryOfRefinedMeshTest::CPPUNIT_TEST

(

testBoundarySerialization

)

CPPUNIT_TEST_SUITE_END()

BoundaryOfRefinedMeshTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE() [1/2]

BoundaryMeshTest::LIBMESH_CPPUNIT_TEST_SUITE ( BoundaryMeshTest  )

inherited

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

LIBMESH_CPPUNIT_TEST_SUITE() [2/2]

BoundaryOfRefinedMeshTest::LIBMESH_CPPUNIT_TEST_SUITE

(

BoundaryOfRefinedMeshTest

)

The goal of this test is the same as the previous, but now we do a uniform refinement before synchronizing to the boundary mesh rather than after.

sanityCheck()

void BoundaryMeshTest::sanityCheck ( )

inlineinherited

Definition at line 477 of file boundary_mesh.C.

References libMesh::EDGE3, libMesh::QUAD9, and libMesh::TOLERANCE.

  {
    sanity_check_mesh(*_mesh, EDGE3, QUAD9, true);
    sanity_check_mesh(*_multi_boundary_mesh, EDGE3, QUAD9, false);
    sanity_check_mesh(*_exterior_boundary_mesh, EDGE3, QUAD9, false);
    sanity_check_mesh(*_left_boundary_mesh, EDGE3, QUAD9, false);
    sanity_check_mesh(*_internal_boundary_mesh, EDGE3, QUAD9, false);

    for (const auto & elem : _left_boundary_mesh->active_element_ptr_range())
      {
        // We only added left edges here
        LIBMESH_ASSERT_FP_EQUAL(0.2, elem->vertex_average()(0),
                                TOLERANCE*TOLERANCE);
      }

    // Sanity check for the internal sideset mesh.
    for (const auto & elem : _internal_boundary_mesh->active_element_ptr_range())
      {
        // All of the elements in the internal sideset mesh should
        // have the same subdomain id as the parent Elems (i.e. 1)
        // they came from.
        CPPUNIT_ASSERT_EQUAL(static_cast<subdomain_id_type>(1),
                             elem->subdomain_id());
      }
  }

setUp()

void BoundaryOfRefinedMeshTest::setUp ( )

inline

Definition at line 665 of file boundary_mesh.C.

References libMesh::MeshRefinement::uniformly_refine().

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

    // Refine interior mesh before creating boundary meshes
    MeshRefinement(*_mesh).uniformly_refine(1);

    this->sync_and_test_meshes();
#endif
  }

sync_and_test_meshes()

void BoundaryMeshTest::sync_and_test_meshes ( )

inlineprotectedinherited

Definition at line 351 of file boundary_mesh.C.

  {
    // Get the border of the square
    const std::set<boundary_id_type> exterior_boundaries {0, 1, 2, 3};
    _mesh->get_boundary_info().sync(exterior_boundaries,
                                    *_exterior_boundary_mesh);
    check_parent_side_index_tag(*_exterior_boundary_mesh);

    // The mesh of all boundaries is, because of the two nodes each
    // joining three edges where the internal boundary meets the
    // external boundary, not a manifold mesh.  We still have work to
    // do to properly support non-manifold meshes, and
    // find_neighbors() when preparing such a mesh is likely to fail,
    // so we'll just do the best test we can here, requesting a set of
    // three different boundaries.  We drop the left and bottom
    // boundaries because they have any T intersections with the
    // interior boundaries, and we drop one of the interior boundaries
    // because with both together we'd have 4 edges meeting at every
    // interior boundary vertex.
    const std::set<boundary_id_type> multi_boundaries {1, 2, 5};
    _mesh->get_boundary_info().sync(multi_boundaries,
                                    *_multi_boundary_mesh);
    check_parent_side_index_tag(*_multi_boundary_mesh);

    std::set<boundary_id_type> left_id, right_id;
    left_id.insert(3);
    right_id.insert(1);

    // 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.
    _mesh->get_boundary_info().add_elements
      (right_id, *_mesh, /*store_parent_side_ids=*/false);
    _mesh->prepare_for_use();

    // Add the left side of the square to its own boundary mesh.
    _mesh->get_boundary_info().sync(left_id, *_left_boundary_mesh);
    check_parent_side_index_tag(*_left_boundary_mesh);

    // Create a BoundaryMesh from the internal sidesets relative to subdomain 1.
    {
      std::set<boundary_id_type> requested_boundary_ids {bid1, bid2};
      std::set<subdomain_id_type> subdomains_relative_to;
      subdomains_relative_to.insert(1);
      _mesh->get_boundary_info().sync(requested_boundary_ids,
                                      *_internal_boundary_mesh,
                                      subdomains_relative_to);
      check_parent_side_index_tag(*_internal_boundary_mesh);
    }
  }

testBoundarySerialization()

void BoundaryOfRefinedMeshTest::testBoundarySerialization ( )

inline

Definition at line 747 of file boundary_mesh.C.

  {
    LOG_UNIT_TEST;

    MeshSerializer internal_serializer(*_internal_boundary_mesh);

    // There'd better be 2*4 active elements on the internal
    // sideset mesh
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(8),
                         _internal_boundary_mesh->n_active_elem());

    // Plus the original 4 now-inactive elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(12),
                         _internal_boundary_mesh->n_elem());

    // There'd better be 2*2*4+1 nodes on the internal boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(17),
                         _internal_boundary_mesh->n_nodes());

    this->sanityCheck();
  }

testMesh()

void BoundaryOfRefinedMeshTest::testMesh ( )

inline

Definition at line 677 of file boundary_mesh.C.

  {
    LOG_UNIT_TEST;

    // There'd better be 3*5*4 + 5*2 active elements in the interior
    // plus right boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(70),
                         _mesh->n_active_elem());

    // Plus the original 20 now-inactive elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(90),
                         _mesh->n_elem());

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

    // There'd better be 2*2*(3+5) active elements on the exterior boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(32),
                         _exterior_boundary_mesh->n_active_elem());

    // Plus the original 16 now-inactive elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(48),
                         _exterior_boundary_mesh->n_elem());

    // There'd better be 2*2*2*(3+5) nodes on the exterior boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(64),
                         _exterior_boundary_mesh->n_nodes());

    // There'd better be 2*5 active elements on the left boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(10),
                         _left_boundary_mesh->n_active_elem());

    // Plus the original 5 now-inactive elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(15),
                         _left_boundary_mesh->n_elem());

    // There'd better be 2*2*5+1 nodes on the left boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(21),
                         _left_boundary_mesh->n_nodes());

    // There'd better be 2*4 active elements on the internal
    // sideset mesh
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(8),
                         _internal_boundary_mesh->n_active_elem());

    // Plus the original 4 now-inactive elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(12),
                         _internal_boundary_mesh->n_elem());

    // There'd better be 2*2*4+1 nodes on the one-sided internal boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(17),
                         _internal_boundary_mesh->n_nodes());

    // There'd better be 2*(3+5) + 2*4 active elements on the
    // multi-boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(24),
                         _multi_boundary_mesh->n_active_elem());

    // Plus the original 12 now-inactive elements
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(36),
                         _multi_boundary_mesh->n_elem());

    // There'd better be 2*2*2*(3+5) + 2*2*4-1 nodes on the total boundary
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(50),
                         _multi_boundary_mesh->n_nodes());

    this->sanityCheck();
  }

Member Data Documentation

_exterior_boundary_mesh

std::unique_ptr<UnstructuredMesh> BoundaryMeshTest::_exterior_boundary_mesh

protectedinherited

Definition at line 260 of file boundary_mesh.C.

_internal_boundary_mesh

std::unique_ptr<UnstructuredMesh> BoundaryMeshTest::_internal_boundary_mesh

protectedinherited

Definition at line 262 of file boundary_mesh.C.

_left_boundary_mesh

std::unique_ptr<UnstructuredMesh> BoundaryMeshTest::_left_boundary_mesh

protectedinherited

Definition at line 261 of file boundary_mesh.C.

_mesh

std::unique_ptr<UnstructuredMesh> BoundaryMeshTest::_mesh

protectedinherited

Definition at line 258 of file boundary_mesh.C.

_multi_boundary_mesh

std::unique_ptr<UnstructuredMesh> BoundaryMeshTest::_multi_boundary_mesh

protectedinherited

Definition at line 259 of file boundary_mesh.C.

bid1

constexpr boundary_id_type BoundaryMeshTest::bid1 = 5

staticprotectedinherited

Definition at line 266 of file boundary_mesh.C.

bid2

constexpr boundary_id_type BoundaryMeshTest::bid2 = 6

staticprotectedinherited

Definition at line 267 of file boundary_mesh.C.

---

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

• tests/mesh/boundary_mesh.C