OverlappingFunctorTest Class Reference

Inheritance diagram for OverlappingFunctorTest:

Public Member Functions
	CPPUNIT_TEST_SUITE (OverlappingFunctorTest)
	CPPUNIT_TEST (checkCouplingFunctorQuad)
	CPPUNIT_TEST (checkCouplingFunctorQuadUnifRef)
	CPPUNIT_TEST (checkCouplingFunctorTri)
	CPPUNIT_TEST (checkCouplingFunctorTriUnifRef)
	CPPUNIT_TEST (checkOverlappingPartitioner)
	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 (MeshBase &mesh)
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 355 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 238 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 = libmesh_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( new Quad4 );
      elem->set_id(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( new Quad4 );
      elem->set_id(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( new Quad4 );
      elem->set_id(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() = libmesh_make_unique<OverlappingTestPartitioner>();
 
    _mesh->prepare_for_use();
 
#ifdef LIBMESH_ENABLE_AMR
    if (n_refinements > 0)
      {
        MeshRefinement refine(*_mesh);
        refine.uniformly_refine(n_refinements);
      }
#endif // LIBMESH_ENABLE_AMR
  }

References libMesh::DofObject::set_id(), libMesh::Elem::set_node(), libMesh::Elem::subdomain_id(), TestCommWorld, and libMesh::MeshRefinement::uniformly_refine().

checkCouplingFunctorQuad()

void OverlappingFunctorTest::checkCouplingFunctorQuad ( )

inline

Definition at line 385 of file overlapping_coupling_test.C.

  { this->run_coupling_functor_test(0); }

checkCouplingFunctorQuadUnifRef()

void OverlappingFunctorTest::checkCouplingFunctorQuadUnifRef ( )

inline

Definition at line 388 of file overlapping_coupling_test.C.

  { this->run_coupling_functor_test(1); }

checkCouplingFunctorTri()

void OverlappingFunctorTest::checkCouplingFunctorTri ( )

inline

Definition at line 391 of file overlapping_coupling_test.C.

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

References libMesh::MeshTools::Modification::all_tri().

checkCouplingFunctorTriUnifRef()

void OverlappingFunctorTest::checkCouplingFunctorTriUnifRef ( )

inline

Definition at line 398 of file overlapping_coupling_test.C.

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

References libMesh::MeshTools::Modification::all_tri().

checkOverlappingPartitioner()

void OverlappingFunctorTest::checkOverlappingPartitioner ( )

inline

Definition at line 405 of file overlapping_coupling_test.C.

  {
    this->run_partitioner_test(0);
  }

checkOverlappingPartitionerUnifRef()

void OverlappingFunctorTest::checkOverlappingPartitionerUnifRef ( )

inline

Definition at line 410 of file overlapping_coupling_test.C.

  {
    this->run_partitioner_test(1);
  }

clear()

void OverlappingTestBase::clear ( )

inlineprotectedinherited

Definition at line 324 of file overlapping_coupling_test.C.

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

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()

OverlappingFunctorTest::CPPUNIT_TEST_SUITE

(

OverlappingFunctorTest

)

CPPUNIT_TEST_SUITE_END()

OverlappingFunctorTest::CPPUNIT_TEST_SUITE_END

(

)

init()

void OverlappingTestBase::init ( MeshBase &  mesh )

inlineprotectedinherited

Definition at line 304 of file overlapping_coupling_test.C.

  {
    _es = libmesh_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 libMesh::System::add_variable(), libMesh::FIRST, and libMesh::LAGRANGE.

run_coupling_functor_test()

void OverlappingFunctorTest::run_coupling_functor_test ( unsigned int  n_refinements )

inlineprivate

Definition at line 421 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();
      }
#endif
 
    System & system = _es->get_system("SimpleSystem");
 
    OverlappingCouplingFunctor coupling_functor(system);
 
    std::unordered_map<const Elem *,const CouplingMatrix*> subdomain_one_couplings;
    std::unordered_map<const Elem *,const CouplingMatrix*> 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, (dof_id_type) subdomain_one_couplings.size() );
    CPPUNIT_ASSERT_EQUAL( dof_id_type(2*n_elems_subdomain_two), (dof_id_type) subdomain_two_couplings.size() );
  }

References distance(), libMesh::DofObject::invalid_processor_id, and libMesh::MeshRefinement::uniformly_refine().

run_partitioner_test()

void OverlappingFunctorTest::run_partitioner_test ( unsigned int  n_refinements )

inlineprivate

Definition at line 456 of file overlapping_coupling_test.C.

  {
#ifdef LIBMESH_ENABLE_AMR
    if( n_refinements > 0 )
      {
        MeshRefinement refine(*_mesh);
        refine.uniformly_refine(n_refinements);
        _es->reinit();
      }
#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, (int)sub_one_proc_ids.size() );
        CPPUNIT_ASSERT_EQUAL( 1, (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 libMesh::ParallelObject::n_processors(), and libMesh::MeshRefinement::uniformly_refine().

setUp()

void OverlappingFunctorTest::setUp ( )

inline

Definition at line 376 of file overlapping_coupling_test.C.

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

References libMesh::TriangleWrapper::init().

setup_coupling_matrix()

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

inlineprotectedinherited

Definition at line 330 of file overlapping_coupling_test.C.

  {
    System & system = _es->get_system("SimpleSystem");
 
    coupling = libmesh_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 libMesh::System::n_vars(), and libMesh::System::variable_number().

tearDown()

void OverlappingFunctorTest::tearDown ( )

inline

Definition at line 382 of file overlapping_coupling_test.C.

  { this->clear(); }

Member Data Documentation

_es

std::unique_ptr<EquationSystems> OverlappingTestBase::_es

protectedinherited

Definition at line 236 of file overlapping_coupling_test.C.

_mesh

std::unique_ptr<MeshBase> OverlappingTestBase::_mesh

protectedinherited

Definition at line 234 of file overlapping_coupling_test.C.

---

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

• tests/base/overlapping_coupling_test.C