Inheritance diagram for PointNeighborCouplingTest:

[legend]

Public Member Functions
	LIBMESH_CPPUNIT_TEST_SUITE (PointNeighborCouplingTest)

	CPPUNIT_TEST (testCouplingOnEdge3)

	CPPUNIT_TEST (testCouplingOnQuad9)

	CPPUNIT_TEST (testCouplingOnTri6)

	CPPUNIT_TEST (testCouplingOnHex27)

	CPPUNIT_TEST_SUITE_END ()

void	setUp ()

void	tearDown ()

void	testCoupling (const ElemType elem_type)

void	testCouplingOnEdge3 ()

void	testCouplingOnQuad9 ()

void	testCouplingOnTri6 ()

void	testCouplingOnHex27 ()

Detailed Description

Definition at line 32 of file point_neighbor_coupling_test.C.

Member Function Documentation

◆ CPPUNIT_TEST() [1/4]

PointNeighborCouplingTest::CPPUNIT_TEST ( testCouplingOnEdge3 )

◆ CPPUNIT_TEST() [2/4]

PointNeighborCouplingTest::CPPUNIT_TEST ( testCouplingOnHex27 )

◆ CPPUNIT_TEST() [3/4]

PointNeighborCouplingTest::CPPUNIT_TEST ( testCouplingOnQuad9 )

◆ CPPUNIT_TEST() [4/4]

PointNeighborCouplingTest::CPPUNIT_TEST ( testCouplingOnTri6 )

◆ CPPUNIT_TEST_SUITE_END()

PointNeighborCouplingTest::CPPUNIT_TEST_SUITE_END ( )

◆ LIBMESH_CPPUNIT_TEST_SUITE()

PointNeighborCouplingTest::LIBMESH_CPPUNIT_TEST_SUITE ( PointNeighborCouplingTest )

◆ setUp()

void PointNeighborCouplingTest::setUp ( )

inline

Definition at line 50 of file point_neighbor_coupling_test.C.

51 {}

◆ tearDown()

void PointNeighborCouplingTest::tearDown ( )

inline

Definition at line 53 of file point_neighbor_coupling_test.C.

54 {}

◆ testCoupling()

void PointNeighborCouplingTest::testCoupling ( const ElemType elem_type )

inline

Definition at line 56 of file point_neighbor_coupling_test.C.

  {
    Mesh mesh(*TestCommWorld);
 
    EquationSystems es(mesh);
    System &sys = es.add_system<System> ("SimpleSystem");
    sys.add_variable("u", THIRD, HIERARCHIC);
 
    // Remove the default DoF ghosting functors
    sys.get_dof_map().remove_coupling_functor
      (sys.get_dof_map().default_coupling());
    sys.get_dof_map().remove_algebraic_ghosting_functor
      (sys.get_dof_map().default_algebraic_ghosting());
 
    // Create a replacement functor
    PointNeighborCoupling point_neighbor_coupling;
 
    // This just re-sets the default; real users may want a real
    // coupling matrix instead.
    point_neighbor_coupling.set_dof_coupling(nullptr);
 
    point_neighbor_coupling.set_n_levels(3);
 
    sys.get_dof_map().add_algebraic_ghosting_functor
      (point_neighbor_coupling);
 
    const unsigned int n_elem_per_side = 5;
    const std::unique_ptr<Elem> test_elem = Elem::build(elem_type);
    const unsigned int ymax = test_elem->dim() > 1;
    const unsigned int zmax = test_elem->dim() > 2;
    const unsigned int ny = ymax * n_elem_per_side;
    const unsigned int nz = zmax * n_elem_per_side;
 
    MeshTools::Generation::build_cube (mesh,
                                       n_elem_per_side,
                                       ny,
                                       nz,
                                       0., 1.,
                                       0., ymax,
                                       0., zmax,
                                       elem_type);
 
    es.init();
    sys.project_solution(cubic_point_neighbor_coupling_test, nullptr, es.parameters);
 
    for (const auto & elem : mesh.active_local_element_ptr_range())
      for (unsigned int s1=0; s1 != elem->n_neighbors(); ++s1)
        {
          const Elem * n1 = elem->neighbor_ptr(s1);
          if (!n1)
            continue;
 
          libmesh_assert(sys.get_dof_map().is_evaluable(*n1, 0));
 
          // Let's speed up this test by only checking the ghosted
          // elements which are most likely to break.
          if (n1->processor_id() == mesh.processor_id())
            continue;
 
          for (unsigned int s2=0; s2 != elem->n_neighbors(); ++s2)
            {
              const Elem * n2 = elem->neighbor_ptr(s2);
              if (!n2 ||
                  n2->processor_id() == mesh.processor_id())
                continue;
 
              libmesh_assert(sys.get_dof_map().is_evaluable(*n2, 0));
 
              for (unsigned int s3=0; s3 != elem->n_neighbors(); ++s3)
                {
                  const Elem * n3 = elem->neighbor_ptr(s3);
                  if (!n3 ||
                      n3->processor_id() == mesh.processor_id())
                    continue;
 
                  libmesh_assert(sys.get_dof_map().is_evaluable(*n3, 0));
 
                  Point p = n3->vertex_average();
 
                  LIBMESH_ASSERT_NUMBERS_EQUAL(sys.point_value(0,p,n3),
                                              cubic_point_neighbor_coupling_test(p,es.parameters,"",""),
                                              TOLERANCE*TOLERANCE);
                }
            }
        }
  }