libMesh
Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | List of all members
OverlappingCouplingGhostingTest Class Reference
Inheritance diagram for OverlappingCouplingGhostingTest:
[legend]

Public Member Functions

 LIBMESH_CPPUNIT_TEST_SUITE (OverlappingCouplingGhostingTest)
 
 CPPUNIT_TEST (testSparsityCouplingMatrix)
 
 CPPUNIT_TEST (testSparsityNullCouplingMatrix)
 
 CPPUNIT_TEST (testSparsityNullCouplingMatrixUnifRef)
 
 CPPUNIT_TEST_SUITE_END ()
 
void setUp ()
 
void tearDown ()
 
void testSparsityCouplingMatrix ()
 
void testSparsityNullCouplingMatrix ()
 
void testSparsityNullCouplingMatrixUnifRef ()
 

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_sparsity_pattern_test (const unsigned int n_refinements, bool build_coupling_matrix)
 

Detailed Description

Definition at line 622 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.

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

239  {
240  // We are making assumptions in various places about the presence
241  // of the elements on the current processor so we're restricting to
242  // ReplicatedMesh for now.
243  _mesh = std::make_unique<ReplicatedMesh>(*TestCommWorld);
244 
245  _mesh->set_mesh_dimension(2);
246 
247  _mesh->add_point( Point(0.0,0.0),0 );
248  _mesh->add_point( Point(1.0,0.0),1 );
249  _mesh->add_point( Point(1.0,1.0),2 );
250  _mesh->add_point( Point(0.0,1.0),3 );
251 
252  {
253  Elem * elem = _mesh->add_elem(Elem::build_with_id(QUAD4, 0));
254  elem->subdomain_id() = 1;
255 
256  for (unsigned int n=0; n<4; n++)
257  elem->set_node(n) = _mesh->node_ptr(n);
258  }
259 
260  _mesh->add_point( Point(1.0,2.0),4 );
261  _mesh->add_point( Point(0.0,2.0),5 );
262 
263  {
264  Elem * elem = _mesh->add_elem(Elem::build_with_id(QUAD4, 1));
265  elem->subdomain_id() = 1;
266 
267  elem->set_node(0) = _mesh->node_ptr(3);
268  elem->set_node(1) = _mesh->node_ptr(2);
269  elem->set_node(2) = _mesh->node_ptr(4);
270  elem->set_node(3) = _mesh->node_ptr(5);
271  }
272 
273  _mesh->add_point( Point(0.0,0.0),6 );
274  _mesh->add_point( Point(1.0,0.0),7 );
275  _mesh->add_point( Point(1.0,2.0),8 );
276  _mesh->add_point( Point(0.0,2.0),9 );
277 
278  {
279  Elem* elem = _mesh->add_elem(Elem::build_with_id(QUAD4, 2));
280  elem->subdomain_id() = 2;
281 
282  elem->set_node(0) = _mesh->node_ptr(6);
283  elem->set_node(1) = _mesh->node_ptr(7);
284  elem->set_node(2) = _mesh->node_ptr(8);
285  elem->set_node(3) = _mesh->node_ptr(9);
286  }
287 
288  _mesh->partitioner() = std::make_unique<OverlappingTestPartitioner>();
289 
290  _mesh->prepare_for_use();
291 
292 #ifdef LIBMESH_ENABLE_AMR
293  if (n_refinements > 0)
294  {
295  MeshRefinement refine(*_mesh);
296  refine.uniformly_refine(n_refinements);
297  }
298 #endif // LIBMESH_ENABLE_AMR
299  }
virtual Node *& set_node(const unsigned int i)
Definition: elem.h:2381
This is the base class from which all geometric element types are derived.
Definition: elem.h:94
std::unique_ptr< MeshBase > _mesh
Implements (adaptive) mesh refinement algorithms for a MeshBase.
subdomain_id_type subdomain_id() const
Definition: elem.h:2391
A Point defines a location in LIBMESH_DIM dimensional Real space.
Definition: point.h:39

◆ clear()

void OverlappingTestBase::clear ( )
inlineprotectedinherited

Definition at line 321 of file overlapping_coupling_test.C.

322  {
323  _es.reset();
324  _mesh.reset();
325  }
std::unique_ptr< MeshBase > _mesh
std::unique_ptr< EquationSystems > _es

◆ CPPUNIT_TEST() [1/3]

OverlappingCouplingGhostingTest::CPPUNIT_TEST ( testSparsityCouplingMatrix  )

◆ CPPUNIT_TEST() [2/3]

OverlappingCouplingGhostingTest::CPPUNIT_TEST ( testSparsityNullCouplingMatrix  )

◆ CPPUNIT_TEST() [3/3]

OverlappingCouplingGhostingTest::CPPUNIT_TEST ( testSparsityNullCouplingMatrixUnifRef  )

◆ CPPUNIT_TEST_SUITE_END()

OverlappingCouplingGhostingTest::CPPUNIT_TEST_SUITE_END ( )

◆ init()

void OverlappingTestBase::init ( )
inlineprotectedinherited

Definition at line 301 of file overlapping_coupling_test.C.

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

302  {
303  _es = std::make_unique<EquationSystems>(*_mesh);
304  LinearImplicitSystem & sys = _es->add_system<LinearImplicitSystem> ("SimpleSystem");
305 
306  std::set<subdomain_id_type> sub_one;
307  sub_one.insert(1);
308 
309  std::set<subdomain_id_type> sub_two;
310  sub_two.insert(2);
311 
312  sys.add_variable("U", FIRST, LAGRANGE, &sub_two);
313  sys.add_variable("L", FIRST, LAGRANGE, &sub_two);
314 
315  sys.add_variable("V", FIRST, LAGRANGE, &sub_one);
316  sys.add_variable("p", FIRST, LAGRANGE, &sub_one);
317 
318  _es->init();
319  }
Manages consistently variables, degrees of freedom, coefficient vectors, matrices and linear solvers ...
std::unique_ptr< EquationSystems > _es
unsigned int add_variable(std::string_view var, const FEType &type, const std::set< subdomain_id_type > *const active_subdomains=nullptr)
Adds the variable var to the list of variables for this system.
Definition: system.C:1305

◆ LIBMESH_CPPUNIT_TEST_SUITE()

OverlappingCouplingGhostingTest::LIBMESH_CPPUNIT_TEST_SUITE ( OverlappingCouplingGhostingTest  )

◆ run_sparsity_pattern_test()

void OverlappingCouplingGhostingTest::run_sparsity_pattern_test ( const unsigned int  n_refinements,
bool  build_coupling_matrix 
)
inlineprivate

Definition at line 662 of file overlapping_coupling_test.C.

References libMesh::DofMap::add_coupling_functor(), libMesh::SparseMatrix< T >::add_matrix(), libMesh::NumericVector< T >::build(), libMesh::DofMap::clear_sparsity(), libMesh::SparseMatrix< T >::close(), libMesh::ParallelObject::comm(), libMesh::DofMap::compute_sparsity(), libMesh::System::current_local_solution, libMesh::FEMContext::elem_fe_reinit(), libMesh::DiffContext::get_dof_indices(), libMesh::System::get_dof_map(), libMesh::DiffContext::get_elem_jacobian(), libMesh::FEMContext::get_element_fe(), libMesh::System::get_mesh(), libMesh::DofMap::get_send_list(), libMesh::ImplicitSystem::get_system_matrix(), libMesh::DenseMatrix< T >::get_values(), libMesh::GHOSTED, libMesh::TriangleWrapper::init(), libMesh::SparseMatrix< T >::init(), libMesh::DofMap::is_attached(), libMesh::libmesh_assert(), libMesh::System::n_dofs(), libMesh::System::n_local_dofs(), libMesh::FEMContext::pre_fe_reinit(), libMesh::DofMap::reinit_send_list(), libMesh::DenseMatrix< T >::resize(), libMesh::System::solution, and libMesh::System::variable_number().

663  {
664  this->build_quad_mesh(n_refinements);
665  this->init();
666 
667  std::unique_ptr<CouplingMatrix> coupling_matrix;
668  if (build_coupling_matrix)
669  this->setup_coupling_matrix(coupling_matrix);
670 
671  LinearImplicitSystem & system = _es->get_system<LinearImplicitSystem>("SimpleSystem");
672 
673  // If we don't add this coupling functor and properly recompute the
674  // sparsity pattern, then PETSc will throw a malloc error when we
675  // try to assemble into the global matrix
676  OverlappingCouplingFunctor coupling_functor(system);
677  coupling_functor.set_coupling_matrix(coupling_matrix);
678 
679  DofMap & dof_map = system.get_dof_map();
680  dof_map.add_coupling_functor(coupling_functor);
681  dof_map.reinit_send_list(system.get_mesh());
682 
683  // Update current local solution
685 
686  system.current_local_solution->init(system.n_dofs(), system.n_local_dofs(),
687  dof_map.get_send_list(), false,
689 
690  system.solution->localize(*(system.current_local_solution),dof_map.get_send_list());
691 
692  // Now that we've added the coupling functor, we need
693  // to recompute the sparsity
694  dof_map.clear_sparsity();
695  dof_map.compute_sparsity(system.get_mesh());
696 
697  // Now that we've recomputed the sparsity pattern, we need
698  // to reinitialize the system matrix.
699  SparseMatrix<Number> & matrix = system.get_system_matrix();
700  libmesh_assert(dof_map.is_attached(matrix));
701  matrix.init();
702 
703  std::unique_ptr<PointLocatorBase> point_locator = _mesh->sub_point_locator();
704 
705  const unsigned int u_var = system.variable_number("U");
706  const unsigned int v_var = system.variable_number("V");
707 
708  DenseMatrix<Number> K12, K21;
709 
710  FEMContext subdomain_one_context(system);
711  subdomain_one_context.get_element_fe(u_var)->get_nothing();
712  subdomain_one_context.get_element_fe(v_var)->get_nothing();
713 
714  FEMContext subdomain_two_context(system);
715  subdomain_two_context.get_element_fe(u_var)->get_xyz();
716  subdomain_two_context.get_element_fe(v_var)->get_nothing();
717 
718  // Add normally coupled parts of the matrix
719  for (const auto & elem : _mesh->active_local_subdomain_elements_ptr_range(1))
720  {
721  subdomain_one_context.pre_fe_reinit(system,elem);
722  subdomain_one_context.elem_fe_reinit();
723 
724  std::vector<dof_id_type> & rows = subdomain_one_context.get_dof_indices();
725 
726  // Fill with ones in case PETSc ignores the zeros at some point
727  std::fill( subdomain_one_context.get_elem_jacobian().get_values().begin(),
728  subdomain_one_context.get_elem_jacobian().get_values().end(),
729  1);
730 
731  // Insert the Jacobian for the dofs for this element
732  matrix.add_matrix( subdomain_one_context.get_elem_jacobian(), rows );
733  }
734 
735  for (const auto & elem : _mesh->active_local_subdomain_elements_ptr_range(2))
736  {
737  // A little extra unit testing on the range iterator
738  CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(elem->subdomain_id()));
739 
740  const std::vector<libMesh::Point> & qpoints = subdomain_two_context.get_element_fe(u_var)->get_xyz();
741 
742  // Setup the context for the current element
743  subdomain_two_context.pre_fe_reinit(system,elem);
744  subdomain_two_context.elem_fe_reinit();
745 
746  // We're only assembling rows for the dofs on subdomain 2 (U,L), so
747  // the current element will have all those dof_indices.
748  std::vector<dof_id_type> & rows = subdomain_two_context.get_dof_indices();
749 
750  std::fill( subdomain_two_context.get_elem_jacobian().get_values().begin(),
751  subdomain_two_context.get_elem_jacobian().get_values().end(),
752  1);
753 
754  // Insert the Jacobian for the normally coupled dofs for this element
755  matrix.add_matrix( subdomain_two_context.get_elem_jacobian(), rows );
756 
757  std::set<subdomain_id_type> allowed_subdomains;
758  allowed_subdomains.insert(1);
759 
760  // Now loop over the quadrature points and find the subdomain-one element that overlaps
761  // with the current subdomain-two element and then add a local element matrix with
762  // the coupling to the global matrix to try and trip any issues with sparsity pattern
763  // construction
764  for ( const auto & qp : qpoints )
765  {
766  const Elem * overlapping_elem = (*point_locator)( qp, &allowed_subdomains );
767  CPPUNIT_ASSERT(overlapping_elem);
768 
769  // Setup the context for the overlapping element
770  subdomain_one_context.pre_fe_reinit(system,overlapping_elem);
771  subdomain_one_context.elem_fe_reinit();
772 
773  // We're only coupling to the "V" variable so only need those dof indices
774  std::vector<dof_id_type> & v_indices = subdomain_one_context.get_dof_indices(v_var);
775  std::vector<dof_id_type> columns(rows);
776  columns.insert( columns.end(), v_indices.begin(), v_indices.end() );
777 
778  // This will also zero the matrix so we can just insert zeros for this test
779  K21.resize( rows.size(), columns.size() );
780 
781  std::fill(K21.get_values().begin(), K21.get_values().end(), 1);
782 
783  // Now adding this local matrix to the global would trip a PETSc
784  // malloc error if the sparsity pattern hasn't been correctly
785  // built to include the overlapping coupling.
786  matrix.add_matrix (K21, rows, columns);
787 
788  // Now add the other part of the overlapping coupling
789  K12.resize(v_indices.size(), rows.size());
790  std::fill(K12.get_values().begin(), K12.get_values().end(), 1);
791  matrix.add_matrix(K12,v_indices,rows);
792  }
793  } // end element loop
794 
795  // We need to make sure to close the matrix for this test. There could still
796  // be PETSc malloc errors tripped here if we didn't allocate the off-processor
797  // part of the sparsity pattern correctly.
798  matrix.close();
799  }
void setup_coupling_matrix(std::unique_ptr< CouplingMatrix > &coupling)
Manages consistently variables, degrees of freedom, coefficient vectors, matrices and linear solvers ...
bool is_attached(SparseMatrix< Number > &matrix)
Matrices should not be attached more than once.
Definition: dof_map.C:333
This is the base class from which all geometric element types are derived.
Definition: elem.h:94
const Parallel::Communicator & comm() const
dof_id_type n_local_dofs() const
Definition: system.C:150
const MeshBase & get_mesh() const
Definition: system.h:2277
void add_coupling_functor(GhostingFunctor &coupling_functor, bool to_mesh=true)
Adds a functor which can specify coupling requirements for creation of sparse matrices.
Definition: dof_map.C:1861
dof_id_type n_dofs() const
Definition: system.C:113
unsigned int variable_number(std::string_view var) const
Definition: system.C:1557
std::unique_ptr< MeshBase > _mesh
std::unique_ptr< EquationSystems > _es
This class handles the numbering of degrees of freedom on a mesh.
Definition: dof_map.h:169
void build_quad_mesh(unsigned int n_refinements=0)
void reinit_send_list(MeshBase &mesh)
Clears the _send_list vector and then rebuilds it.
Definition: dof_map.C:1734
virtual void add_matrix(const DenseMatrix< T > &dm, const std::vector< numeric_index_type > &rows, const std::vector< numeric_index_type > &cols)=0
Add the full matrix dm to the SparseMatrix.
std::unique_ptr< NumericVector< Number > > solution
Data structure to hold solution values.
Definition: system.h:1573
libmesh_assert(ctx)
This class provides all data required for a physics package (e.g.
Definition: fem_context.h:62
std::vector< T > & get_values()
Definition: dense_matrix.h:382
static std::unique_ptr< NumericVector< T > > build(const Parallel::Communicator &comm, const SolverPackage solver_package=libMesh::default_solver_package())
Builds a NumericVector on the processors in communicator comm using the linear solver package specifi...
virtual void close()=0
Calls the SparseMatrix&#39;s internal assembly routines, ensuring that the values are consistent across p...
void resize(const unsigned int new_m, const unsigned int new_n)
Resizes the matrix to the specified size and calls zero().
Definition: dense_matrix.h:895
void clear_sparsity()
Clears the sparsity pattern.
Definition: dof_map.C:1837
std::unique_ptr< NumericVector< Number > > current_local_solution
All the values I need to compute my contribution to the simulation at hand.
Definition: system.h:1585
void compute_sparsity(const MeshBase &)
Computes the sparsity pattern for the matrices corresponding to proc_id and sends that data to Linear...
Definition: dof_map.C:1816
const DofMap & get_dof_map() const
Definition: system.h:2293
const SparseMatrix< Number > & get_system_matrix() const
const std::vector< dof_id_type > & get_send_list() const
Definition: dof_map.h:511
virtual void init(const numeric_index_type m, const numeric_index_type n, const numeric_index_type m_l, const numeric_index_type n_l, const numeric_index_type nnz=30, const numeric_index_type noz=10, const numeric_index_type blocksize=1)=0
Initialize SparseMatrix with the specified sizes.

◆ setUp()

void OverlappingCouplingGhostingTest::setUp ( )
inline

Definition at line 636 of file overlapping_coupling_test.C.

637  {}

◆ setup_coupling_matrix()

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

Definition at line 327 of file overlapping_coupling_test.C.

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

328  {
329  System & system = _es->get_system("SimpleSystem");
330 
331  coupling = std::make_unique<CouplingMatrix>(system.n_vars());
332 
333  const unsigned int u_var = system.variable_number("U");
334  const unsigned int l_var = system.variable_number("L");
335  const unsigned int v_var = system.variable_number("V");
336  const unsigned int p_var = system.variable_number("p");
337 
338  // Only adding the overlapping couplings since the primary ones should
339  // be there by default.
340  (*coupling)(u_var,v_var) = true;
341  (*coupling)(l_var,v_var) = true;
342  (*coupling)(l_var,p_var) = true;
343  (*coupling)(v_var,u_var) = true;
344  (*coupling)(v_var,l_var) = true;
345  }
unsigned int variable_number(std::string_view var) const
Definition: system.C:1557
std::unique_ptr< EquationSystems > _es
Manages consistently variables, degrees of freedom, and coefficient vectors.
Definition: system.h:96
unsigned int n_vars() const
Definition: system.h:2349

◆ tearDown()

void OverlappingCouplingGhostingTest::tearDown ( )
inline

Definition at line 639 of file overlapping_coupling_test.C.

640  { this->clear(); }

◆ testSparsityCouplingMatrix()

void OverlappingCouplingGhostingTest::testSparsityCouplingMatrix ( )
inline

Definition at line 642 of file overlapping_coupling_test.C.

643  {
644  LOG_UNIT_TEST;
645  this->run_sparsity_pattern_test(0, true);
646  }
void run_sparsity_pattern_test(const unsigned int n_refinements, bool build_coupling_matrix)

◆ testSparsityNullCouplingMatrix()

void OverlappingCouplingGhostingTest::testSparsityNullCouplingMatrix ( )
inline

Definition at line 648 of file overlapping_coupling_test.C.

649  {
650  LOG_UNIT_TEST;
651  this->run_sparsity_pattern_test(0, false);
652  }
void run_sparsity_pattern_test(const unsigned int n_refinements, bool build_coupling_matrix)

◆ testSparsityNullCouplingMatrixUnifRef()

void OverlappingCouplingGhostingTest::testSparsityNullCouplingMatrixUnifRef ( )
inline

Definition at line 654 of file overlapping_coupling_test.C.

655  {
656  LOG_UNIT_TEST;
657  this->run_sparsity_pattern_test(1, false);
658  }
void run_sparsity_pattern_test(const unsigned int n_refinements, bool build_coupling_matrix)

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: