Inheritance diagram for FEGLLLagrangeAgreementTest< elem_type, order >:

[legend]

Public Member Functions
void	setUp ()

void	tearDown ()

Point	gll_point (const unsigned int i, const unsigned int dim)
	The interpolation point of Gauss-Lobatto shape function `i`.

unsigned int	node_at (const Elem &elem, const Point &q)
	The node of `elem` whose reference position is `q`, or invalid_uint if it has none.

void	testAgreesWithLagrange ()

Protected Attributes
std::unique_ptr< Mesh >	_mesh

std::string	libmesh_suite_name

Detailed Description

template<ElemType elem_type, Order order>
class FEGLLLagrangeAgreementTest< elem_type, order >

Definition at line 32 of file fe_gll_lagrange_agreement_test.C.

Member Function Documentation

◆ gll_point()

template<ElemType elem_type, Order order>

Point FEGLLLagrangeAgreementTest< elem_type, order >::gll_point	(	const unsigned int	i,
		const unsigned int	dim
	)

inline

The interpolation point of Gauss-Lobatto shape function i.

Definition at line 56 of file fe_gll_lagrange_agreement_test.C.

  {
    const unsigned int n = static_cast<unsigned int>(order) + 1;
 
    // QGaussLobatto chooses n points for order 2n-3
    QGaussLobatto rule(1, static_cast<Order>(2*n - 3));
    rule.init(EDGE2);
 
    Point q;
    unsigned int stride = 1;
 
    for (const auto d : make_range(dim))
      {
        q(d) = rule.qp((i / stride) % n)(0);
        stride *= n;
      }
 
    return q;
  }

References dim, libMesh::EDGE2, libMesh::QBase::init(), libMesh::make_range(), and libMesh::QBase::qp().

Referenced by FEGLLLagrangeAgreementTest< elem_type, order >::testAgreesWithLagrange().

◆ node_at()

template<ElemType elem_type, Order order>

unsigned int FEGLLLagrangeAgreementTest< elem_type, order >::node_at	(	const Elem &	elem,
		const Point &	q
	)

inline

The node of elem whose reference position is q, or invalid_uint if it has none.

Definition at line 77 of file fe_gll_lagrange_agreement_test.C.

  {
    unsigned int found = invalid_uint;
 
    for (const auto n : elem.node_index_range())
      if (elem.master_point(n).relative_fuzzy_equals(q, TOLERANCE))
        {
          // Each shape function must pair with exactly one node
          CPPUNIT_ASSERT_EQUAL(invalid_uint, found);
          found = n;
        }
 
    return found;
  }

References libMesh::invalid_uint, libMesh::Elem::master_point(), libMesh::Elem::node_index_range(), libMesh::TypeVector< T >::relative_fuzzy_equals(), and libMesh::TOLERANCE.

Referenced by FEGLLLagrangeAgreementTest< elem_type, order >::testAgreesWithLagrange().

◆ setUp()

template<ElemType elem_type, Order order>

void FEGLLLagrangeAgreementTest< elem_type, order >::setUp ( )

inline

Definition at line 39 of file fe_gll_lagrange_agreement_test.C.

  {
    _mesh = std::make_unique<Mesh>(*TestCommWorld);
 
    const unsigned int dim = Elem::type_to_dim_map[elem_type];
 
    if (dim == 1)
      MeshTools::Generation::build_line(*_mesh, 1, 0., 1., elem_type);
    else if (dim == 2)
      MeshTools::Generation::build_square(*_mesh, 1, 1, 0., 1., 0., 1., elem_type);
    else
      MeshTools::Generation::build_cube(*_mesh, 1, 1, 1, 0., 1., 0., 1., 0., 1., elem_type);
  }

References FEGLLLagrangeAgreementTest< elem_type, order >::_mesh, libMesh::MeshTools::Generation::build_cube(), libMesh::MeshTools::Generation::build_line(), libMesh::MeshTools::Generation::build_square(), dim, TestCommWorld, and libMesh::Elem::type_to_dim_map.

◆ tearDown()

template<ElemType elem_type, Order order>

void FEGLLLagrangeAgreementTest< elem_type, order >::tearDown ( )

inline

Definition at line 53 of file fe_gll_lagrange_agreement_test.C.

53{ _mesh.reset(); }

References FEGLLLagrangeAgreementTest< elem_type, order >::_mesh.

◆ testAgreesWithLagrange()

template<ElemType elem_type, Order order>

void FEGLLLagrangeAgreementTest< elem_type, order >::testAgreesWithLagrange ( )

inline

Definition at line 92 of file fe_gll_lagrange_agreement_test.C.

  {
    LOG_UNIT_TEST;
 
    const unsigned int dim = Elem::type_to_dim_map[elem_type];
 
    const FEType gll_type(order, L2_LAGRANGE_GLL);
    const FEType lagrange_type(order, LAGRANGE);
 
    // Sample on a grid spread over the reference element, so that most points lie between
    // the interpolation points
    std::vector<Point> samples;
    for (const auto a : make_range(-3, 4))
      for (const auto b : make_range(-3, 4))
        for (const auto c : make_range(-3, 4))
          samples.emplace_back(a/7., (dim > 1) ? b/7. : 0., (dim > 2) ? c/7. : 0.);
 
    unsigned int n_paired = 0;
 
    for (const auto * elem : _mesh->active_local_element_ptr_range())
      {
        const unsigned int n_gll = FEInterface::n_shape_functions(gll_type, elem);
        const unsigned int n_lag = FEInterface::n_shape_functions(lagrange_type, elem);
 
        // The two bases span the same space here, so their sizes match
        CPPUNIT_ASSERT_EQUAL(n_lag, n_gll);
 
        for (const auto i : make_range(n_gll))
          {
            const unsigned int n = node_at(*elem, gll_point(i, dim));
            CPPUNIT_ASSERT(n != invalid_uint);
 
            for (const Point & q : samples)
              LIBMESH_ASSERT_FP_EQUAL(FEInterface::shape(lagrange_type, elem, n, q),
                                      FEInterface::shape(gll_type, elem, i, q),
                                      TOLERANCE*TOLERANCE);
 
            ++n_paired;
          }
      }
 
    _mesh->comm().sum(n_paired);
    CPPUNIT_ASSERT(n_paired > 0);
  }