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 365 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 249 of file overlapping_coupling_test.C.

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

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

checkCouplingFunctorQuad()

void OverlappingFunctorTest::checkCouplingFunctorQuad ( )

inline

Definition at line 397 of file overlapping_coupling_test.C.

  { this->run_coupling_functor_test(0); }

checkCouplingFunctorQuadUnifRef()

void OverlappingFunctorTest::checkCouplingFunctorQuadUnifRef ( )

inline

Definition at line 400 of file overlapping_coupling_test.C.

  { this->run_coupling_functor_test(1); }

checkCouplingFunctorTri()

void OverlappingFunctorTest::checkCouplingFunctorTri ( )

inline

Definition at line 403 of file overlapping_coupling_test.C.

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

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

checkCouplingFunctorTriUnifRef()

void OverlappingFunctorTest::checkCouplingFunctorTriUnifRef ( )

inline

Definition at line 410 of file overlapping_coupling_test.C.

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

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

checkOverlappingPartitioner()

void OverlappingFunctorTest::checkOverlappingPartitioner ( )

inline

Definition at line 417 of file overlapping_coupling_test.C.

  {
    this->run_partitioner_test(0);
  }

checkOverlappingPartitionerUnifRef()

void OverlappingFunctorTest::checkOverlappingPartitionerUnifRef ( )

inline

Definition at line 422 of file overlapping_coupling_test.C.

  {
    this->run_partitioner_test(1);
  }

clear()

void OverlappingTestBase::clear ( )

inlineprotectedinherited

Definition at line 334 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

(

checkCouplingFunctorTri

)

CPPUNIT_TEST() [3/6]

OverlappingFunctorTest::CPPUNIT_TEST

(

checkOverlappingPartitioner

)

CPPUNIT_TEST() [4/6]

OverlappingFunctorTest::CPPUNIT_TEST

(

checkCouplingFunctorQuadUnifRef

)

CPPUNIT_TEST() [5/6]

OverlappingFunctorTest::CPPUNIT_TEST

(

checkCouplingFunctorTriUnifRef

)

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 314 of file overlapping_coupling_test.C.

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

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

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 433 of file overlapping_coupling_test.C.

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

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

run_partitioner_test()

void OverlappingFunctorTest::run_partitioner_test ( unsigned int  n_refinements )

inlineprivate

Definition at line 470 of file overlapping_coupling_test.C.

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

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

setUp()

void OverlappingFunctorTest::setUp ( )

inline

Definition at line 388 of file overlapping_coupling_test.C.

References libMesh::TriangleWrapper::init().

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

setup_coupling_matrix()

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

inlineprotectedinherited

Definition at line 340 of file overlapping_coupling_test.C.

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

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

tearDown()

void OverlappingFunctorTest::tearDown ( )

inline

Definition at line 394 of file overlapping_coupling_test.C.

  { this->clear(); }

Member Data Documentation

_es

std::unique_ptr<EquationSystems> OverlappingTestBase::_es

protectedinherited

Definition at line 247 of file overlapping_coupling_test.C.

_mesh

std::unique_ptr<MeshBase> OverlappingTestBase::_mesh

protectedinherited

Definition at line 245 of file overlapping_coupling_test.C.

---

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

• tests/base/overlapping_coupling_test.C