Inheritance diagram for OverlappingTestBase:

[legend]

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

Detailed Description

Definition at line 243 of file overlapping_coupling_test.C.

Member Function Documentation

◆ build_quad_mesh()

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

inlineprotected

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 _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 OverlappingFunctorTest::setUp().

◆ clear()

void OverlappingTestBase::clear ( )

inlineprotected

Definition at line 336 of file overlapping_coupling_test.C.

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

References _es, and _mesh.

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

◆ init()

void OverlappingTestBase::init ( )

inlineprotected

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

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

◆ setup_coupling_matrix()

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

inlineprotected

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