Inheritance diagram for NonManifoldGhostingFunctorTest:

[legend]

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (NonManifoldGhostingFunctorTest)

	CPPUNIT_TEST (verifySendListEntries0)

	CPPUNIT_TEST (verifySendListEntries1)

	CPPUNIT_TEST (verifySendListEntries2)

	CPPUNIT_TEST (verifySendListEntries3)

	CPPUNIT_TEST_SUITE_END ()

void	setUp ()

void	tearDown ()

void	verifySendListEntries0 ()

void	verifySendListEntries1 ()

void	verifySendListEntries2 ()

void	verifySendListEntries3 ()

void	verify_send_list_entries_helper (const std::string &mesh_filename)

Protected Member Functions
void	read_mesh (const std::string &mesh_filename)

void	init_es ()

Protected Attributes
std::unique_ptr< MeshBase >	_mesh

std::unique_ptr< EquationSystems >	_es

Detailed Description

Definition at line 167 of file nonmanifold_coupling_test.C.

Member Function Documentation

◆ CPPUNIT_TEST() [1/4]

NonManifoldGhostingFunctorTest::CPPUNIT_TEST ( verifySendListEntries0 )

◆ CPPUNIT_TEST() [2/4]

NonManifoldGhostingFunctorTest::CPPUNIT_TEST ( verifySendListEntries1 )

◆ CPPUNIT_TEST() [3/4]

NonManifoldGhostingFunctorTest::CPPUNIT_TEST ( verifySendListEntries2 )

◆ CPPUNIT_TEST() [4/4]

NonManifoldGhostingFunctorTest::CPPUNIT_TEST ( verifySendListEntries3 )

◆ CPPUNIT_TEST_SUITE_END()

NonManifoldGhostingFunctorTest::CPPUNIT_TEST_SUITE_END ( )

◆ init_es()

void NonManifoldCouplingTestBase::init_es ( )

inlineprotectedinherited

Definition at line 142 of file nonmanifold_coupling_test.C.

  {
    _es = std::make_unique<EquationSystems>(*_mesh);
 
    // Add System with a single linear Lagrange variable on it.
    LinearImplicitSystem & sys = _es->add_system<LinearImplicitSystem> ("SimpleSystem");
    sys.add_variable("u", FIRST, LAGRANGE);
 
    // Attach ghosting functor to the System. We use the std::shared_ptr interface
    // so that the DofMap takes ownership of the object. Note: if you comment out
    // this line, then the test _can_ fail when run in parallel, but it depends on
    // the number of processors used. For small numbers of procs, sometimes we can
    // get "lucky" and wind up with all the non-manifold neighbor DOFs either local
    // to or ghosted on all procs where they are needed. In practice, this test should
    // be run on 3 or more procs to make it fail when the NonManifoldGhostingFunctor
    // is not used.
    auto ghosting_functor = std::make_shared<NonManifoldGhostingFunctor>(*_mesh);
    sys.get_dof_map().add_coupling_functor(ghosting_functor, /*to_mesh=*/true);
 
    // Initialize the DofMap, etc. for all Systems
    _es->init();
  }

References NonManifoldCouplingTestBase::_es, NonManifoldCouplingTestBase::_mesh, libMesh::DofMap::add_coupling_functor(), libMesh::System::add_variable(), libMesh::FIRST, libMesh::System::get_dof_map(), and libMesh::LAGRANGE.

Referenced by verify_send_list_entries_helper().

◆ LIBMESH_CPPUNIT_TEST_SUITE()

NonManifoldGhostingFunctorTest::LIBMESH_CPPUNIT_TEST_SUITE ( NonManifoldGhostingFunctorTest )

◆ read_mesh()

void NonManifoldCouplingTestBase::read_mesh ( const std::string & mesh_filename )

inlineprotectedinherited

Definition at line 123 of file nonmanifold_coupling_test.C.

  {
    // We are making assumptions in various places about the presence
    // of the elements on the current processor so we're restricting to
    // ReplicatedMesh for now.
    _mesh = std::make_unique<ReplicatedMesh>(*TestCommWorld);
    _mesh->read(mesh_filename);
 
    // Use our custom partitioner that assigns non-manifold edge
    // neighbors to different processors.
    _mesh->partitioner() = std::make_unique<NonManifoldTestPartitioner>();
 
    _mesh->prepare_for_use();
 
    // Debugging: print processor ids determined by partitioner
    // for (const auto & elem : _mesh->element_ptr_range())
    //   libMesh::out << "Elem " << elem->id() << " is on processor " << elem->processor_id() << std::endl;
  }

References NonManifoldCouplingTestBase::_mesh, and TestCommWorld.

Referenced by verify_send_list_entries_helper().

◆ setUp()

void NonManifoldGhostingFunctorTest::setUp ( )

inline

Definition at line 185 of file nonmanifold_coupling_test.C.

186 {

187 }

◆ tearDown()

void NonManifoldGhostingFunctorTest::tearDown ( )

inline

Definition at line 189 of file nonmanifold_coupling_test.C.

190 {

191 }

◆ verify_send_list_entries_helper()

void NonManifoldGhostingFunctorTest::verify_send_list_entries_helper ( const std::string & mesh_filename )

inline

Definition at line 200 of file nonmanifold_coupling_test.C.

  {
    // Call base class implementations
    this->read_mesh(mesh_filename);
    this->init_es();
 
    // Get reference to the System, corresponding DofMap, and send_list for this processor
    System & system = _es->get_system("SimpleSystem");
    DofMap & dof_map = system.get_dof_map();
    const std::vector<dof_id_type> & send_list = dof_map.get_send_list();
 
    MeshTools::SidesToElemMap stem = MeshTools::SidesToElemMap::build(*_mesh);
 
    // Use the SidesToElemMap to get a range of Elem pointers attached
    // to the non-manifold edge that we intentionally partitioned onto
    // different processors.
    MeshTools::SidesToElemMap::ElemIter beg, end;
    auto side_neighbors_found = [&]() -> bool
    {
      for (const auto & elem : _mesh->element_ptr_range())
        for (auto s : elem->side_index_range())
          {
            auto range = stem.get_connected_elems(elem, s);
            if (std::distance(range.first, range.second) == 5)
              {
                beg = range.first;
                end = range.second;
                return true;
              }
          }
 
      // If we made it here, then we didn't find a Side shared by
      // 5 elements and we'll throw an error later
      return false;
    }();
 
    // Require that neighbors were found
    CPPUNIT_ASSERT(side_neighbors_found);
 
    // For every pair of elements (e,f) on this edge owned by processors (proc_e, proc_f) respectively, check that:
    // 1.) The DOFs of e are either local to, or in the send-list of, proc_f
    // 2.) The DOFs of f are either local to, or in the send-list of, proc_e
    for (auto it_e = beg; it_e != end; ++it_e)
      for (auto it_f = std::next(it_e); it_f != end; ++it_f)
        {
          // Lambda to be used for error checking
          auto check_dofs = [&](const Elem * elem)
          {
            std::vector<dof_id_type> dof_indices;
            dof_map.dof_indices(elem, dof_indices);
 
            for (const auto & dof : dof_indices)
            {
              bool is_local = (dof >= dof_map.first_dof()) && (dof < dof_map.end_dof());
              bool is_in_send_list = (Utility::binary_find(send_list.begin(), send_list.end(), dof) != send_list.end());
              CPPUNIT_ASSERT(is_local || is_in_send_list);
            }
          };
 
          const Elem * elem_e = *it_e;
          const Elem * elem_f = *it_f;
 
          if (_mesh->comm().rank() == elem_e->processor_id())
            check_dofs(elem_f);
 
          if (_mesh->comm().rank() == elem_f->processor_id())
            check_dofs(elem_e);
        }
  }