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.

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

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

◆ 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;
   }

◆ 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.

References libMesh::Utility::binary_find(), libMesh::MeshTools::SidesToElemMap::build(), distance(), libMesh::DofMap::dof_indices(), libMesh::DofMapBase::end_dof(), libMesh::DofMapBase::first_dof(), libMesh::MeshTools::SidesToElemMap::get_connected_elems(), libMesh::System::get_dof_map(), libMesh::DofMap::get_send_list(), libMesh::MeshTools::Subdivision::next, and libMesh::DofObject::processor_id().

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