FEGLLCollocationTest< elem_type, order > Class Template Reference

Inheritance diagram for FEGLLCollocationTest< elem_type, order >:

Public Member Functions
void	setUp ()
void	tearDown ()
std::unique_ptr< QBase >	collocated_rule (const FEType &fe_type, const unsigned int dim)
	The family's default quadrature rule, which is collocated with the basis.
void	testShapesAreIdentity ()
void	testMassMatrixIsDiagonal ()

Protected Attributes
std::unique_ptr< Mesh >	_mesh
std::string	libmesh_suite_name

Detailed Description

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

Definition at line 33 of file fe_gll_collocation_test.C.

Member Function Documentation

collocated_rule()

template<ElemType elem_type, Order order>

std::unique_ptr< QBase > FEGLLCollocationTest< elem_type, order >::collocated_rule ( const FEType &  fe_type, const unsigned int  dim  )

inline

The family's default quadrature rule, which is collocated with the basis.

Definition at line 69 of file fe_gll_collocation_test.C.

  {
    return fe_type.default_quadrature_rule(dim);
  }

References libMesh::FEType::default_quadrature_rule(), and dim.

Referenced by FEGLLCollocationTest< elem_type, order >::testMassMatrixIsDiagonal(), and FEGLLCollocationTest< elem_type, order >::testShapesAreIdentity().

setUp()

template<ElemType elem_type, Order order>

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

inline

Definition at line 40 of file fe_gll_collocation_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, 2, 0., 1., elem_type);
    else if (dim == 2)
      MeshTools::Generation::build_square(*_mesh, 2, 2, 0., 1., 0., 1., elem_type);
    else
      MeshTools::Generation::build_cube(*_mesh, 2, 2, 2, 0., 1., 0., 1., 0., 1., elem_type);
 
    // Shear the mesh so that the mapping to each element has off-diagonal Jacobian terms
    for (auto * node : _mesh->node_ptr_range())
      {
        Node & p = *node;
        const Real y = (LIBMESH_DIM > 1) ? p(1) : 0.;
        const Real z = (LIBMESH_DIM > 2) ? p(2) : 0.;
 
        p(0) += 0.3 * y + 0.17 * z;
        if (LIBMESH_DIM > 1)
          p(1) += 0.23 * z;
      }
  }

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

tearDown()

template<ElemType elem_type, Order order>

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

inline

Definition at line 66 of file fe_gll_collocation_test.C.

{ _mesh.reset(); }

References FEGLLCollocationTest< elem_type, order >::_mesh.

testMassMatrixIsDiagonal()

template<ElemType elem_type, Order order>

void FEGLLCollocationTest< elem_type, order >::testMassMatrixIsDiagonal ( )

inline

Definition at line 108 of file fe_gll_collocation_test.C.

  {
    LOG_UNIT_TEST;
 
    const FEType fe_type(order, L2_LAGRANGE_GLL);
    const unsigned int dim = Elem::type_to_dim_map[elem_type];
 
    std::unique_ptr<FEBase> fe = FEBase::build(dim, fe_type);
    std::unique_ptr<QBase> qrule = collocated_rule(fe_type, dim);
    fe->attach_quadrature_rule(qrule.get());
 
    const std::vector<std::vector<Real>> & phi = fe->get_phi();
    const std::vector<Real> & JxW = fe->get_JxW();
 
    for (const auto * elem : _mesh->active_local_element_ptr_range())
      {
        fe->reinit(elem);
 
        const std::size_t n_dofs = phi.size();
 
        for (const auto i : make_range(n_dofs))
          for (const auto j : make_range(n_dofs))
            {
              Real m = 0.;
              for (const auto q : index_range(JxW))
                m += JxW[q] * phi[i][q] * phi[j][q];
 
              if (i == j)
                {
                  // Each diagonal entry equals JxW at its own point, which is positive on
                  // a valid element
                  CPPUNIT_ASSERT(m > 0.);
                  LIBMESH_ASSERT_FP_EQUAL(JxW[i], m, TOLERANCE*TOLERANCE);
                }
              else
                CPPUNIT_ASSERT_EQUAL(Real(0), m);
            }
      }
  }

References FEGLLCollocationTest< elem_type, order >::_mesh, libMesh::FEGenericBase< OutputType >::build(), FEGLLCollocationTest< elem_type, order >::collocated_rule(), dim, libMesh::index_range(), libMesh::L2_LAGRANGE_GLL, libMesh::make_range(), libMesh::Real, libMesh::TOLERANCE, and libMesh::Elem::type_to_dim_map.

testShapesAreIdentity()

template<ElemType elem_type, Order order>

void FEGLLCollocationTest< elem_type, order >::testShapesAreIdentity ( )

inline

Definition at line 74 of file fe_gll_collocation_test.C.

  {
    LOG_UNIT_TEST;
 
    const FEType fe_type(order, L2_LAGRANGE_GLL);
    const unsigned int dim = Elem::type_to_dim_map[elem_type];
 
    std::unique_ptr<FEBase> fe = FEBase::build(dim, fe_type);
    std::unique_ptr<QBase> qrule = collocated_rule(fe_type, dim);
    fe->attach_quadrature_rule(qrule.get());
 
    // Request phi before reinit so that reinit computes it
    const std::vector<std::vector<Real>> & phi = fe->get_phi();
 
    unsigned int n_elem = 0;
 
    for (const auto * elem : _mesh->active_local_element_ptr_range())
      {
        fe->reinit(elem);
 
        // The collocated rule has one point per degree of freedom
        CPPUNIT_ASSERT_EQUAL(phi.size(), std::size_t(qrule->n_points()));
 
        for (const auto i : index_range(phi))
          for (const auto q : index_range(phi[i]))
            CPPUNIT_ASSERT_EQUAL((i == q) ? Real(1) : Real(0), phi[i][q]);
 
        ++n_elem;
      }
 
    _mesh->comm().sum(n_elem);
    CPPUNIT_ASSERT(n_elem > 0);
  }

References FEGLLCollocationTest< elem_type, order >::_mesh, libMesh::FEGenericBase< OutputType >::build(), FEGLLCollocationTest< elem_type, order >::collocated_rule(), dim, libMesh::index_range(), libMesh::L2_LAGRANGE_GLL, libMesh::Real, and libMesh::Elem::type_to_dim_map.

Member Data Documentation

_mesh

template<ElemType elem_type, Order order>

std::unique_ptr<Mesh> FEGLLCollocationTest< elem_type, order >::_mesh

protected

Definition at line 36 of file fe_gll_collocation_test.C.

Referenced by FEGLLCollocationTest< elem_type, order >::setUp(), FEGLLCollocationTest< elem_type, order >::tearDown(), FEGLLCollocationTest< elem_type, order >::testMassMatrixIsDiagonal(), and FEGLLCollocationTest< elem_type, order >::testShapesAreIdentity().

libmesh_suite_name

template<ElemType elem_type, Order order>

std::string FEGLLCollocationTest< elem_type, order >::libmesh_suite_name

protected

Definition at line 37 of file fe_gll_collocation_test.C.

---

The documentation for this class was generated from the following file:

• tests/fe/fe_gll_collocation_test.C