ConnectedComponentsTest Class Reference

Inheritance diagram for ConnectedComponentsTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (ConnectedComponentsTest)
	The goal of this test is to ensure that the count returned by MeshTools::n_connected_components() is correct for hand-checked cases.
	CPPUNIT_TEST (testEdge2)
	These tests require a valid solver package to be enabled because they build a SparseMatrix.
	CPPUNIT_TEST (testEdge3)
	CPPUNIT_TEST (testEdge4)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	testEdge2 ()
void	testEdge3 ()
void	testEdge4 ()

Protected Member Functions
void	testEdge (unsigned n_elem, ElemType elem_type)

Detailed Description

Definition at line 18 of file connected_components.C.

Member Function Documentation

CPPUNIT_TEST() [1/3]

ConnectedComponentsTest::CPPUNIT_TEST

(

testEdge2

)

These tests require a valid solver package to be enabled because they build a SparseMatrix.

Note: LIBMESH_HAVE_SOLVER is actually defined in libmesh/system.h

CPPUNIT_TEST() [2/3]

ConnectedComponentsTest::CPPUNIT_TEST

(

testEdge3

)

CPPUNIT_TEST() [3/3]

ConnectedComponentsTest::CPPUNIT_TEST

(

testEdge4

)

CPPUNIT_TEST_SUITE_END()

ConnectedComponentsTest::CPPUNIT_TEST_SUITE_END

(

)

LIBMESH_CPPUNIT_TEST_SUITE()

ConnectedComponentsTest::LIBMESH_CPPUNIT_TEST_SUITE

(

ConnectedComponentsTest

)

The goal of this test is to ensure that the count returned by MeshTools::n_connected_components() is correct for hand-checked cases.

setUp()

void ConnectedComponentsTest::setUp ( )

inline

Definition at line 134 of file connected_components.C.

{}

tearDown()

void ConnectedComponentsTest::tearDown ( )

inline

Definition at line 136 of file connected_components.C.

{}

testEdge()

void ConnectedComponentsTest::testEdge ( unsigned  n_elem, ElemType  elem_type  )

inlineprotected

Definition at line 43 of file connected_components.C.

  {
    Mesh mesh(*TestCommWorld);
 
    // We don't yet support n_connected_components() on distributed
    // meshes
    mesh.allow_remote_element_removal(false);
 
    MeshTools::Generation::build_line(mesh,
                                      n_elem,
                                      /*xmin=*/0.,
                                      /*xmax=*/1.,
                                      elem_type);
 
    const dof_id_type n_components_orig =
      MeshTools::n_connected_components(mesh);
 
    CPPUNIT_ASSERT_EQUAL(n_components_orig, dof_id_type(1));
 
    // We can't disconnect a too-small mesh
    if (n_elem < 3)
      return;
 
    for (const auto & elem : mesh.element_ptr_range())
      {
        const Point c = elem->vertex_average();
 
        if (std::abs(c(0) - 0.5) < 0.2)
          mesh.delete_elem(elem);
      }
 
    mesh.prepare_for_use();
 
    const dof_id_type n_components_broken =
      MeshTools::n_connected_components(mesh);
 
    CPPUNIT_ASSERT_EQUAL(n_components_broken, dof_id_type(2));
 
    // Add a constraint connecting the original end nodes
    auto matrix = SparseMatrix<Number>::build (mesh.comm());
 
    dof_id_type left_node = 0, right_node = 0;
    for (const auto & elem : mesh.element_ptr_range())
      for (const auto & node : elem->node_ref_range())
        {
          if (node(0) == Real(0))
            left_node = node.id();
          if (node(0) == Real(1))
            right_node = node.id();
        }
 
    mesh.comm().max(left_node);
    mesh.comm().max(right_node);
 
    const dof_id_type n_nodes = mesh.n_nodes();
    CPPUNIT_ASSERT_EQUAL(n_nodes, mesh.max_node_id());
 
    processor_id_type my_rank = mesh.comm().rank();
    matrix->init(n_nodes, n_nodes-1,
                 (my_rank ? 0 : n_nodes),
                 (my_rank ? 0 : n_nodes-1),
                 (my_rank ? 0 : n_nodes-1),
                 0);
 
    if (!my_rank)
      {
        for (auto i : make_range(n_nodes))
          {
            if (i < right_node)
              matrix->set(i,i,1);
            if (i > right_node)
              matrix->set(i,i-1,1);
          }
        if (left_node > right_node)
          matrix->set(right_node, left_node-1, 1);
        else
          matrix->set(right_node, left_node, 1);
      }
 
    matrix->close();
 
    mesh.copy_constraint_rows(*matrix);
 
    const dof_id_type n_components_constrained =
      MeshTools::n_connected_components(mesh);
 
    CPPUNIT_ASSERT_EQUAL(n_components_constrained, dof_id_type(1));
  }

References libMesh::MeshBase::allow_remote_element_removal(), libMesh::SparseMatrix< T >::build(), libMesh::MeshTools::Generation::build_line(), libMesh::ParallelObject::comm(), libMesh::MeshBase::copy_constraint_rows(), libMesh::MeshBase::delete_elem(), libMesh::make_range(), libMesh::Parallel::Communicator::max(), libMesh::MeshBase::max_node_id(), mesh, libMesh::MeshTools::n_connected_components(), libMesh::MeshBase::n_nodes(), n_nodes, libMesh::MeshBase::prepare_for_use(), libMesh::Parallel::Communicator::rank(), libMesh::Real, and TestCommWorld.

Referenced by testEdge2(), testEdge3(), and testEdge4().

testEdge2()

void ConnectedComponentsTest::testEdge2 ( )

inline

Definition at line 138 of file connected_components.C.

  {
    LOG_UNIT_TEST;
 
    testEdge(/*n_elem=*/10, EDGE2);
  }

References libMesh::EDGE2, and testEdge().

testEdge3()

void ConnectedComponentsTest::testEdge3 ( )

inline

Definition at line 145 of file connected_components.C.

  {
    LOG_UNIT_TEST;
 
    testEdge(/*n_elem=*/10, EDGE3);
  }

References libMesh::EDGE3, and testEdge().

testEdge4()

void ConnectedComponentsTest::testEdge4 ( )

inline

Definition at line 152 of file connected_components.C.

  {
    LOG_UNIT_TEST;
 
    testEdge(/*n_elem=*/10, EDGE4);
  }

References libMesh::EDGE4, and testEdge().

---

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

• tests/mesh/connected_components.C