OverlappingFunctorTest Class Reference

Inheritance diagram for OverlappingFunctorTest:

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (OverlappingFunctorTest)
	CPPUNIT_TEST (checkCouplingFunctorQuad)
	CPPUNIT_TEST (checkCouplingFunctorTri)
	CPPUNIT_TEST (checkOverlappingPartitioner)
	CPPUNIT_TEST (checkCouplingFunctorQuadUnifRef)
	CPPUNIT_TEST (checkCouplingFunctorTriUnifRef)
	CPPUNIT_TEST (checkOverlappingPartitionerUnifRef)
	CPPUNIT_TEST_SUITE_END ()
void	setUp ()
void	tearDown ()
void	checkCouplingFunctorQuad ()
void	checkCouplingFunctorQuadUnifRef ()
void	checkCouplingFunctorTri ()
void	checkCouplingFunctorTriUnifRef ()
void	checkOverlappingPartitioner ()
void	checkOverlappingPartitionerUnifRef ()

Protected Member Functions
void	build_quad_mesh (unsigned int n_refinements=0)
void	init ()
void	clear ()
void	setup_coupling_matrix (std::unique_ptr< CouplingMatrix > &coupling)

Protected Attributes
std::unique_ptr< MeshBase >	_mesh
std::unique_ptr< EquationSystems >	_es

Private Member Functions
void	run_coupling_functor_test (unsigned int n_refinements)
void	run_partitioner_test (unsigned int n_refinements)

Detailed Description

Definition at line 367 of file overlapping_coupling_test.C.

Member Function Documentation

build_quad_mesh()

void OverlappingTestBase::build_quad_mesh ( unsigned int  n_refinements = 0 )

inlineprotectedinherited

Definition at line 251 of file overlapping_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->set_mesh_dimension(2);
 
    _mesh->add_point( Point(0.0,0.0),0 );
    _mesh->add_point( Point(1.0,0.0),1 );
    _mesh->add_point( Point(1.0,1.0),2 );
    _mesh->add_point( Point(0.0,1.0),3 );
 
    {
      Elem * elem = _mesh->add_elem(Elem::build_with_id(QUAD4, 0));
      elem->subdomain_id() = 1;
 
      for (unsigned int n=0; n<4; n++)
        elem->set_node(n, _mesh->node_ptr(n));
    }
 
    _mesh->add_point( Point(1.0,2.0),4 );
    _mesh->add_point( Point(0.0,2.0),5 );
 
    {
      Elem * elem = _mesh->add_elem(Elem::build_with_id(QUAD4, 1));
      elem->subdomain_id() = 1;
 
      elem->set_node(0, _mesh->node_ptr(3));
      elem->set_node(1, _mesh->node_ptr(2));
      elem->set_node(2, _mesh->node_ptr(4));
      elem->set_node(3, _mesh->node_ptr(5));
    }
 
    _mesh->add_point( Point(0.0,0.0),6 );
    _mesh->add_point( Point(1.0,0.0),7 );
    _mesh->add_point( Point(1.0,2.0),8 );
    _mesh->add_point( Point(0.0,2.0),9 );
 
    {
      Elem* elem = _mesh->add_elem(Elem::build_with_id(QUAD4, 2));
      elem->subdomain_id() = 2;
 
      elem->set_node(0, _mesh->node_ptr(6));
      elem->set_node(1, _mesh->node_ptr(7));
      elem->set_node(2, _mesh->node_ptr(8));
      elem->set_node(3, _mesh->node_ptr(9));
    }
 
    _mesh->partitioner() = std::make_unique<OverlappingTestPartitioner>();
 
    _mesh->prepare_for_use();
 
#ifdef LIBMESH_ENABLE_AMR
    if (n_refinements > 0)
      {
        MeshRefinement refine(*_mesh);
        refine.uniformly_refine(n_refinements);
      }
#else
    CPPUNIT_ASSERT_EQUAL(n_refinements, 0u);
#endif // LIBMESH_ENABLE_AMR
  }

References OverlappingTestBase::_mesh, libMesh::Elem::build_with_id(), libMesh::QUAD4, libMesh::Elem::set_node(), libMesh::Elem::subdomain_id(), TestCommWorld, and libMesh::MeshRefinement::uniformly_refine().

Referenced by OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), and setUp().

checkCouplingFunctorQuad()

void OverlappingFunctorTest::checkCouplingFunctorQuad ( )

inline

Definition at line 399 of file overlapping_coupling_test.C.

  { this->run_coupling_functor_test(0); }

References run_coupling_functor_test().

checkCouplingFunctorQuadUnifRef()

void OverlappingFunctorTest::checkCouplingFunctorQuadUnifRef ( )

inline

Definition at line 402 of file overlapping_coupling_test.C.

  { this->run_coupling_functor_test(1); }

References run_coupling_functor_test().

checkCouplingFunctorTri()

void OverlappingFunctorTest::checkCouplingFunctorTri ( )

inline

Definition at line 405 of file overlapping_coupling_test.C.

  {
    MeshTools::Modification::all_tri(*_mesh);
    _es->reinit();
    this->run_coupling_functor_test(0);
  }

References OverlappingTestBase::_es, OverlappingTestBase::_mesh, libMesh::MeshTools::Modification::all_tri(), and run_coupling_functor_test().

checkCouplingFunctorTriUnifRef()

void OverlappingFunctorTest::checkCouplingFunctorTriUnifRef ( )

inline

Definition at line 412 of file overlapping_coupling_test.C.

  {
    MeshTools::Modification::all_tri(*_mesh);
    _es->reinit();
    this->run_coupling_functor_test(1);
  }

References OverlappingTestBase::_es, OverlappingTestBase::_mesh, libMesh::MeshTools::Modification::all_tri(), and run_coupling_functor_test().

checkOverlappingPartitioner()

void OverlappingFunctorTest::checkOverlappingPartitioner ( )

inline

Definition at line 419 of file overlapping_coupling_test.C.

  {
    this->run_partitioner_test(0);
  }

References run_partitioner_test().

checkOverlappingPartitionerUnifRef()

void OverlappingFunctorTest::checkOverlappingPartitionerUnifRef ( )

inline

Definition at line 424 of file overlapping_coupling_test.C.

  {
    this->run_partitioner_test(1);
  }

References run_partitioner_test().

clear()

void OverlappingTestBase::clear ( )

inlineprotectedinherited

Definition at line 336 of file overlapping_coupling_test.C.

  {
    _es.reset();
    _mesh.reset();
  }

References OverlappingTestBase::_es, and OverlappingTestBase::_mesh.

Referenced by tearDown(), OverlappingAlgebraicGhostingTest::tearDown(), and OverlappingCouplingGhostingTest::tearDown().

CPPUNIT_TEST() [1/6]

OverlappingFunctorTest::CPPUNIT_TEST

(

checkCouplingFunctorQuad

)

CPPUNIT_TEST() [2/6]

OverlappingFunctorTest::CPPUNIT_TEST

(

checkCouplingFunctorQuadUnifRef

)

CPPUNIT_TEST() [3/6]

OverlappingFunctorTest::CPPUNIT_TEST

(

checkCouplingFunctorTri

)

CPPUNIT_TEST() [4/6]

OverlappingFunctorTest::CPPUNIT_TEST

(

checkCouplingFunctorTriUnifRef

)

CPPUNIT_TEST() [5/6]

OverlappingFunctorTest::CPPUNIT_TEST

(

checkOverlappingPartitioner

)

CPPUNIT_TEST() [6/6]

OverlappingFunctorTest::CPPUNIT_TEST

(

checkOverlappingPartitionerUnifRef

)

CPPUNIT_TEST_SUITE_END()

OverlappingFunctorTest::CPPUNIT_TEST_SUITE_END

(

)

init()

void OverlappingTestBase::init ( )

inlineprotectedinherited

Definition at line 316 of file overlapping_coupling_test.C.

  {
    _es = std::make_unique<EquationSystems>(*_mesh);
    LinearImplicitSystem & sys = _es->add_system<LinearImplicitSystem> ("SimpleSystem");
 
    std::set<subdomain_id_type> sub_one;
    sub_one.insert(1);
 
    std::set<subdomain_id_type> sub_two;
    sub_two.insert(2);
 
    sys.add_variable("U", FIRST, LAGRANGE, &sub_two);
    sys.add_variable("L", FIRST, LAGRANGE, &sub_two);
 
    sys.add_variable("V", FIRST, LAGRANGE, &sub_one);
    sys.add_variable("p", FIRST, LAGRANGE, &sub_one);
 
    _es->init();
  }

References OverlappingTestBase::_es, OverlappingTestBase::_mesh, libMesh::System::add_variable(), libMesh::FIRST, and libMesh::LAGRANGE.

Referenced by OverlappingAlgebraicGhostingTest::run_ghosting_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), and setUp().

LIBMESH_CPPUNIT_TEST_SUITE()

OverlappingFunctorTest::LIBMESH_CPPUNIT_TEST_SUITE

(

OverlappingFunctorTest

)

run_coupling_functor_test()

void OverlappingFunctorTest::run_coupling_functor_test ( unsigned int  n_refinements )

inlineprivate

Definition at line 435 of file overlapping_coupling_test.C.

  {
#if defined(LIBMESH_ENABLE_AMR) && defined(LIBMESH_HAVE_SOLVER)
    if( n_refinements > 0 )
      {
        MeshRefinement refine(*_mesh);
        refine.uniformly_refine(n_refinements);
        _es->reinit();
      }
#else
    CPPUNIT_ASSERT_EQUAL(n_refinements, 0u);
#endif
 
    System & system = _es->get_system("SimpleSystem");
 
    OverlappingCouplingFunctor coupling_functor(system);
 
    GhostingFunctor::map_type subdomain_one_couplings;
    GhostingFunctor::map_type subdomain_two_couplings;
 
    coupling_functor( _mesh->active_subdomain_elements_begin(1),
                      _mesh->active_subdomain_elements_end(1),
                      DofObject::invalid_processor_id,
                      subdomain_one_couplings );
 
    coupling_functor( _mesh->active_subdomain_elements_begin(2),
                      _mesh->active_subdomain_elements_end(2),
                      DofObject::invalid_processor_id,
                      subdomain_two_couplings );
 
    dof_id_type n_elems_subdomain_two = std::distance( _mesh->active_subdomain_elements_begin(2),
                                                       _mesh->active_subdomain_elements_end(2) );
 
    CPPUNIT_ASSERT_EQUAL(n_elems_subdomain_two, static_cast<dof_id_type>(subdomain_one_couplings.size()));
    CPPUNIT_ASSERT_EQUAL(static_cast<dof_id_type>(2*n_elems_subdomain_two), static_cast<dof_id_type>(subdomain_two_couplings.size()));
  }

References OverlappingTestBase::_es, OverlappingTestBase::_mesh, libMesh::DofObject::invalid_processor_id, and libMesh::MeshRefinement::uniformly_refine().

Referenced by checkCouplingFunctorQuad(), checkCouplingFunctorQuadUnifRef(), checkCouplingFunctorTri(), and checkCouplingFunctorTriUnifRef().

run_partitioner_test()

void OverlappingFunctorTest::run_partitioner_test ( unsigned int  n_refinements )

inlineprivate

Definition at line 472 of file overlapping_coupling_test.C.

  {
#ifdef LIBMESH_ENABLE_AMR
    if( n_refinements > 0 )
      {
        MeshRefinement refine(*_mesh);
        refine.uniformly_refine(n_refinements);
        _es->reinit();
      }
#else
    CPPUNIT_ASSERT_EQUAL(n_refinements, 0u);
#endif // LIBMESH_ENABLE_AMR
 
    System & system = _es->get_system("SimpleSystem");
 
    std::set<processor_id_type> sub_one_proc_ids, sub_two_proc_ids;
    for (auto & elem : _mesh->active_subdomain_elements_ptr_range(1))
      sub_one_proc_ids.insert(elem->processor_id());
 
    for (auto & elem : _mesh->active_subdomain_elements_ptr_range(2))
      sub_two_proc_ids.insert(elem->processor_id());
 
 
    // Everyone should be on the same processor if only 1 processor
    if( system.n_processors() == 1 )
      {
        CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(sub_one_proc_ids.size()));
        CPPUNIT_ASSERT_EQUAL(1, static_cast<int>(sub_two_proc_ids.size()));
        CPPUNIT_ASSERT( sub_one_proc_ids == sub_two_proc_ids );
      }
    // Otherwise these sets should be disjoint
    else
      {
        // Make sure no subdomain one ids in the subdomain two ids
        for (auto & id : sub_one_proc_ids )
          CPPUNIT_ASSERT( sub_two_proc_ids.find(id) == sub_two_proc_ids.end() );
 
        // Vice-versa
        for (auto & id : sub_two_proc_ids )
          CPPUNIT_ASSERT( sub_one_proc_ids.find(id) == sub_one_proc_ids.end() );
      }
  }

References OverlappingTestBase::_es, OverlappingTestBase::_mesh, libMesh::ParallelObject::n_processors(), and libMesh::MeshRefinement::uniformly_refine().

Referenced by checkOverlappingPartitioner(), and checkOverlappingPartitionerUnifRef().

setUp()

void OverlappingFunctorTest::setUp ( )

inline

Definition at line 390 of file overlapping_coupling_test.C.

  {
    this->build_quad_mesh();
    this->init();
  }

References OverlappingTestBase::build_quad_mesh(), and OverlappingTestBase::init().

setup_coupling_matrix()

void OverlappingTestBase::setup_coupling_matrix ( std::unique_ptr< CouplingMatrix > &  coupling )

inlineprotectedinherited

Definition at line 342 of file overlapping_coupling_test.C.

  {
    System & system = _es->get_system("SimpleSystem");
 
    coupling = std::make_unique<CouplingMatrix>(system.n_vars());
 
    const unsigned int u_var = system.variable_number("U");
    const unsigned int l_var = system.variable_number("L");
    const unsigned int v_var = system.variable_number("V");
    const unsigned int p_var = system.variable_number("p");
 
    // Only adding the overlapping couplings since the primary ones should
    // be there by default.
    (*coupling)(u_var,v_var) = true;
    (*coupling)(l_var,v_var) = true;
    (*coupling)(l_var,p_var) = true;
    (*coupling)(v_var,u_var) = true;
    (*coupling)(v_var,l_var) = true;
  }

References OverlappingTestBase::_es, libMesh::System::n_vars(), and libMesh::System::variable_number().

Referenced by OverlappingAlgebraicGhostingTest::run_ghosting_test(), and OverlappingCouplingGhostingTest::run_sparsity_pattern_test().

tearDown()

void OverlappingFunctorTest::tearDown ( )

inline

Definition at line 396 of file overlapping_coupling_test.C.

  { this->clear(); }

References OverlappingTestBase::clear().

Member Data Documentation

_es

std::unique_ptr<EquationSystems> OverlappingTestBase::_es

protectedinherited

Definition at line 249 of file overlapping_coupling_test.C.

Referenced by checkCouplingFunctorTri(), checkCouplingFunctorTriUnifRef(), OverlappingTestBase::clear(), OverlappingTestBase::init(), run_coupling_functor_test(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), run_partitioner_test(), OverlappingCouplingGhostingTest::run_sparsity_pattern_test(), and OverlappingTestBase::setup_coupling_matrix().

_mesh

std::unique_ptr<MeshBase> OverlappingTestBase::_mesh

protectedinherited

Definition at line 247 of file overlapping_coupling_test.C.

Referenced by OverlappingTestBase::build_quad_mesh(), checkCouplingFunctorTri(), checkCouplingFunctorTriUnifRef(), OverlappingTestBase::clear(), OverlappingTestBase::init(), run_coupling_functor_test(), OverlappingAlgebraicGhostingTest::run_ghosting_test(), run_partitioner_test(), and OverlappingCouplingGhostingTest::run_sparsity_pattern_test().

---

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

• tests/base/overlapping_coupling_test.C