OverlappingCouplingGhostingTest Class Reference

Inheritance diagram for OverlappingCouplingGhostingTest:

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

clear()

void OverlappingTestBase::clear ( )

inlineprotectedinherited

Definition at line 334 of file overlapping_coupling_test.C.

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

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

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

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

    std::unique_ptr<CouplingMatrix> coupling_matrix;
    if (build_coupling_matrix)
      this->setup_coupling_matrix(coupling_matrix);

    LinearImplicitSystem & system = _es->get_system<LinearImplicitSystem>("SimpleSystem");

    // If we don't add this coupling functor and properly recompute the
    // sparsity pattern, then PETSc will throw a malloc error when we
    // try to assemble into the global matrix
    OverlappingCouplingFunctor coupling_functor(system);
    coupling_functor.set_coupling_matrix(coupling_matrix);

    DofMap & dof_map = system.get_dof_map();
    dof_map.add_coupling_functor(coupling_functor);
    dof_map.reinit_send_list(system.get_mesh());

    // Update current local solution
    system.current_local_solution = libMesh::NumericVector<libMesh::Number>::build(system.comm());

    system.current_local_solution->init(system.n_dofs(), system.n_local_dofs(),
                                        dof_map.get_send_list(), false,
                                        libMesh::GHOSTED);

    system.solution->localize(*(system.current_local_solution),dof_map.get_send_list());

    // Now that we've added the coupling functor, we need
    // to recompute the sparsity
    dof_map.clear_sparsity();
    dof_map.compute_sparsity(system.get_mesh());

    // Now that we've recomputed the sparsity pattern, we need
    // to reinitialize the system matrix.
    SparseMatrix<Number> & matrix = system.get_system_matrix();
    libmesh_assert(dof_map.is_attached(matrix));
    matrix.init();

    std::unique_ptr<PointLocatorBase> point_locator = _mesh->sub_point_locator();

    const unsigned int u_var = system.variable_number("U");
    const unsigned int v_var = system.variable_number("V");

    DenseMatrix<Number> K12, K21;

    FEMContext subdomain_one_context(system);
    subdomain_one_context.get_element_fe(u_var)->get_nothing();
    subdomain_one_context.get_element_fe(v_var)->get_nothing();

    FEMContext subdomain_two_context(system);
    subdomain_two_context.get_element_fe(u_var)->get_xyz();
    subdomain_two_context.get_element_fe(v_var)->get_nothing();

    // Add normally coupled parts of the matrix
    for (const auto & elem : _mesh->active_local_subdomain_elements_ptr_range(1))
      {
        subdomain_one_context.pre_fe_reinit(system,elem);
        subdomain_one_context.elem_fe_reinit();

        std::vector<dof_id_type> & rows = subdomain_one_context.get_dof_indices();

        // Fill with ones in case PETSc ignores the zeros at some point
        std::fill( subdomain_one_context.get_elem_jacobian().get_values().begin(),
                   subdomain_one_context.get_elem_jacobian().get_values().end(),
                   1);

        // Insert the Jacobian for the dofs for this element
        matrix.add_matrix( subdomain_one_context.get_elem_jacobian(), rows );
      }

    for (const auto & elem : _mesh->active_local_subdomain_elements_ptr_range(2))
      {
        // A little extra unit testing on the range iterator
        CPPUNIT_ASSERT_EQUAL(2, static_cast<int>(elem->subdomain_id()));

        const std::vector<libMesh::Point> & qpoints = subdomain_two_context.get_element_fe(u_var)->get_xyz();

        // Setup the context for the current element
        subdomain_two_context.pre_fe_reinit(system,elem);
        subdomain_two_context.elem_fe_reinit();

        // We're only assembling rows for the dofs on subdomain 2 (U,L), so
        // the current element will have all those dof_indices.
        std::vector<dof_id_type> & rows = subdomain_two_context.get_dof_indices();

        std::fill( subdomain_two_context.get_elem_jacobian().get_values().begin(),
                   subdomain_two_context.get_elem_jacobian().get_values().end(),
                   1);

        // Insert the Jacobian for the normally coupled dofs for this element
        matrix.add_matrix( subdomain_two_context.get_elem_jacobian(), rows );

        std::set<subdomain_id_type> allowed_subdomains;
        allowed_subdomains.insert(1);

        // Now loop over the quadrature points and find the subdomain-one element that overlaps
        // with the current subdomain-two element and then add a local element matrix with
        // the coupling to the global matrix to try and trip any issues with sparsity pattern
        // construction
        for ( const auto & qp : qpoints )
          {
            const Elem * overlapping_elem = (*point_locator)( qp, &allowed_subdomains );
            CPPUNIT_ASSERT(overlapping_elem);

            // Setup the context for the overlapping element
            subdomain_one_context.pre_fe_reinit(system,overlapping_elem);
            subdomain_one_context.elem_fe_reinit();

            // We're only coupling to the "V" variable so only need those dof indices
            std::vector<dof_id_type> & v_indices = subdomain_one_context.get_dof_indices(v_var);
            std::vector<dof_id_type> columns(rows);
            columns.insert( columns.end(), v_indices.begin(), v_indices.end() );

            // This will also zero the matrix so we can just insert zeros for this test
            K21.resize( rows.size(), columns.size() );

            std::fill(K21.get_values().begin(), K21.get_values().end(), 1);

            // Now adding this local matrix to the global would trip a PETSc
            // malloc error if the sparsity pattern hasn't been correctly
            // built to include the overlapping coupling.
            matrix.add_matrix (K21, rows, columns);

            // Now add the other part of the overlapping coupling
            K12.resize(v_indices.size(), rows.size());
            std::fill(K12.get_values().begin(), K12.get_values().end(), 1);
            matrix.add_matrix(K12,v_indices,rows);
          }
      } // end element loop

    // We need to make sure to close the matrix for this test. There could still
    // be PETSc malloc errors tripped here if we didn't allocate the off-processor
    // part of the sparsity pattern correctly.
    matrix.close();
  }

setUp()

void OverlappingCouplingGhostingTest::setUp ( )

inline

Definition at line 659 of file overlapping_coupling_test.C.

  {}

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 OverlappingCouplingGhostingTest::tearDown ( )

inline

Definition at line 662 of file overlapping_coupling_test.C.

  { this->clear(); }

testSparsityCouplingMatrix()

void OverlappingCouplingGhostingTest::testSparsityCouplingMatrix ( )

inline

Definition at line 665 of file overlapping_coupling_test.C.

  {
    LOG_UNIT_TEST;
    this->run_sparsity_pattern_test(0, true);
  }

testSparsityNullCouplingMatrix()

void OverlappingCouplingGhostingTest::testSparsityNullCouplingMatrix ( )

inline

Definition at line 671 of file overlapping_coupling_test.C.

  {
    LOG_UNIT_TEST;
    this->run_sparsity_pattern_test(0, false);
  }

testSparsityNullCouplingMatrixUnifRef()

void OverlappingCouplingGhostingTest::testSparsityNullCouplingMatrixUnifRef ( )

inline

Definition at line 677 of file overlapping_coupling_test.C.

  {
    LOG_UNIT_TEST;
    this->run_sparsity_pattern_test(1, false);
  }

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