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

◆ clear()

void OverlappingTestBase::clear ( )

inlineprotected

Definition at line 334 of file overlapping_coupling_test.C.

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

◆ init()

void OverlappingTestBase::init ( )

inlineprotected

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

◆ setup_coupling_matrix()

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

inlineprotected

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