FEOrientationTest< elem_type, order, family > Class Template Reference

The orientation tests on a cube of elem_type elements. More...

Inheritance diagram for FEOrientationTest< elem_type, order, family >:

Public Member Functions
void	build_mesh () override
	Builds the mesh the tests run on, before it is skewed.
void	setUp ()
void	tearDown ()
Entity	node_entity (const Elem &elem, const unsigned int n)
	The entity of elem that owns the degrees of freedom sitting on node n.
unsigned int	entity_orientation (const Elem &elem, const Entity &entity)
	The orientation index that the shape functions of entity follow.
void	test_orientation_determines_shapes ()
void	test_conformity_across_sides ()

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

Private Member Functions
unsigned int	n_rounds () const
	Rounds of permutation, which vary the relative numbering of shared sides.
std::vector< Real >	shapes (const FEType &fe_type, const Elem &elem, const unsigned int first, const unsigned int n_dofs, const std::vector< Point > &points)
	The values of shape functions first through first + n_dofs - 1 at points.
void	record (std::map< unsigned int, std::vector< Real > > &seen, const unsigned int orientation, const std::vector< Real > &values, unsigned int &n_compared)
	Record values for orientation, or check them against those already recorded.

Static Private Attributes
static constexpr Real	map_tolerance = TOLERANCE * TOLERANCE
	The tolerance for inverse_map()

Detailed Description

template<ElemType elem_type, Order order, FEFamily family>
class FEOrientationTest< elem_type, order, family >

The orientation tests on a cube of elem_type elements.

Definition at line 269 of file fe_orientation_test.C.

Member Function Documentation

build_mesh()

template<ElemType elem_type, Order order, FEFamily family>

void FEOrientationTest< elem_type, order, family >::build_mesh ( )

inlineoverridevirtual

Builds the mesh the tests run on, before it is skewed.

Implements FEOrientationTestBase< order, family >.

Definition at line 272 of file fe_orientation_test.C.

  {
    const unsigned int dim = Elem::type_to_dim_map[elem_type];
    MeshTools::Generation::build_cube(*this->_mesh, 2, 2, 2*(dim > 2),
                                      0., 1., 0., 1., 0., 1., elem_type);
  }

References FEOrientationTestBase< order, family >::_mesh, libMesh::MeshTools::Generation::build_cube(), dim, and libMesh::Elem::type_to_dim_map.

entity_orientation()

template<Order order, FEFamily family>

unsigned int FEOrientationTestBase< order, family >::entity_orientation ( const Elem &  elem, const Entity &  entity  )

inlineinherited

The orientation index that the shape functions of entity follow.

Definition at line 76 of file fe_orientation_test.C.

  {
    switch (entity.first)
      {
      case EDGE:
        return elem.positive_edge_orientation(entity.second);
      case FACE:
        return elem.face_orientation(entity.second);
      default:
        return 0;
      }
  }

References EDGE, FACE, libMesh::Elem::face_orientation(), and libMesh::Elem::positive_edge_orientation().

Referenced by FEOrientationTestBase< order, family >::test_orientation_determines_shapes().

n_rounds()

template<Order order, FEFamily family>

unsigned int FEOrientationTestBase< order, family >::n_rounds ( ) const

inlineprivateinherited

Rounds of permutation, which vary the relative numbering of shared sides.

Definition at line 221 of file fe_orientation_test.C.

  {
    unsigned int rounds = 0;
    for (const auto * elem : _mesh->element_ptr_range())
      rounds = std::max(rounds, elem->n_permutations());
    _mesh->comm().max(rounds);
    return rounds;
  }

References FEOrientationTestBase< order, family >::_mesh.

Referenced by FEOrientationTestBase< order, family >::test_conformity_across_sides().

node_entity()

template<Order order, FEFamily family>

Entity FEOrientationTestBase< order, family >::node_entity ( const Elem &  elem, const unsigned int  n  )

inlineinherited

The entity of elem that owns the degrees of freedom sitting on node n.

Definition at line 57 of file fe_orientation_test.C.

  {
    if (elem.is_vertex(n))
      return {VERTEX, n};
 
    if (elem.is_edge(n))
      for (const auto e : make_range(elem.n_edges()))
        if (elem.is_node_on_edge(n, e))
          return {EDGE, e};
 
    if (elem.is_face(n))
      for (const auto f : make_range(elem.n_faces()))
        if (elem.is_node_on_side(n, f))
          return {FACE, f};
 
    return {INTERIOR, 0};
  }

References EDGE, FACE, INTERIOR, libMesh::Elem::is_edge(), libMesh::Elem::is_face(), libMesh::Elem::is_node_on_edge(), libMesh::Elem::is_node_on_side(), libMesh::Elem::is_vertex(), libMesh::make_range(), libMesh::Elem::n_edges(), libMesh::Elem::n_faces(), and VERTEX.

Referenced by FEOrientationTestBase< order, family >::test_orientation_determines_shapes().

record()

template<Order order, FEFamily family>

void FEOrientationTestBase< order, family >::record ( std::map< unsigned int, std::vector< Real > > &  seen, const unsigned int  orientation, const std::vector< Real > &  values, unsigned int &  n_compared  )

inlineprivateinherited

Record values for orientation, or check them against those already recorded.

Definition at line 247 of file fe_orientation_test.C.

  {
    const auto [entry, inserted] = seen.emplace(orientation, values);
    if (inserted)
      return;
 
    CPPUNIT_ASSERT_EQUAL(entry->second.size(), values.size());
    for (const auto k : index_range(values))
      LIBMESH_ASSERT_FP_EQUAL(entry->second[k], values[k], TOLERANCE * TOLERANCE);
 
    if (seen.size() > 1)
      ++n_compared;
  }

References libMesh::index_range(), and libMesh::TOLERANCE.

Referenced by FEOrientationTestBase< order, family >::test_orientation_determines_shapes().

setUp()

template<Order order, FEFamily family>

void FEOrientationTestBase< order, family >::setUp ( )

inlineinherited

Definition at line 39 of file fe_orientation_test.C.

  {
    _mesh = std::make_unique<Mesh>(*TestCommWorld);
    build_mesh();
 
    // An affine skew, so that no element symmetry masks a shape function following the wrong
    // entity, and so that inverse_map() is exact
    SkewFunc skew_func;
    MeshTools::Modification::redistribute(*_mesh, skew_func);
    _mesh->complete_preparation();
  }

References FEOrientationTestBase< order, family >::_mesh, FEOrientationTestBase< order, family >::build_mesh(), libMesh::MeshTools::Modification::redistribute(), and TestCommWorld.

shapes()

template<Order order, FEFamily family>

std::vector< Real > FEOrientationTestBase< order, family >::shapes ( const FEType &  fe_type, const Elem &  elem, const unsigned int  first, const unsigned int  n_dofs, const std::vector< Point > &  points  )

inlineprivateinherited

The values of shape functions first through first + n_dofs - 1 at points.

Definition at line 231 of file fe_orientation_test.C.

  {
    std::vector<Real> values;
 
    for (const auto & point : points)
      for (const auto i : make_range(n_dofs))
        values.push_back(FEInterface::shape(fe_type, &elem, first + i, point));
 
    return values;
  }

References libMesh::make_range(), and libMesh::FEInterface::shape().

Referenced by FEOrientationTestBase< order, family >::test_orientation_determines_shapes().

tearDown()

template<Order order, FEFamily family>

void FEOrientationTestBase< order, family >::tearDown ( )

inlineinherited

Definition at line 51 of file fe_orientation_test.C.

{ _mesh.reset(); }

References FEOrientationTestBase< order, family >::_mesh.

test_conformity_across_sides()

template<Order order, FEFamily family>

void FEOrientationTestBase< order, family >::test_conformity_across_sides ( )

inlineinherited

Definition at line 141 of file fe_orientation_test.C.

  {
    LOG_UNIT_TEST;
 
    const FEType fe_type(order, family);
 
    EquationSystems es(*_mesh);
    System & sys = es.add_system<System>("orientation");
    sys.add_variable("u", fe_type);
    es.init();
    const DofMap & dof_map = sys.get_dof_map();
 
    unsigned int n_compared = 0;
 
    for (const auto round : make_range(n_rounds()))
      {
        // Permute by element id so that every processor agrees on the numbering of a ghosted
        // element
        for (auto * elem : _mesh->element_ptr_range())
          elem->permute((round + elem->id()) % elem->n_permutations());
 
        for (const auto * elem : _mesh->active_local_element_ptr_range())
          {
            std::vector<dof_id_type> dofs;
            dof_map.dof_indices(elem, dofs);
 
            for (const auto s : make_range(elem->n_sides()))
              {
                const Elem * neighbor = elem->neighbor_ptr(s);
                if (!neighbor || neighbor == remote_elem)
                  continue;
 
                std::vector<dof_id_type> neighbor_dofs;
                dof_map.dof_indices(neighbor, neighbor_dofs);
 
                std::unique_ptr<const Elem> side = elem->build_side_ptr(s);
                QGauss side_rule(side->dim(), order);
                side_rule.init(*side);
 
                for (const auto & side_point : side_rule.get_points())
                  {
                    const Point physical = FEMap::map(side->dim(), side.get(), side_point);
 
                    // Map far tighter than the shape value tolerance, so mapping error cannot
                    // mask or cause a mismatch
                    const Point point =
                      FEMap::inverse_map(elem->dim(), elem, physical, map_tolerance);
                    const Point neighbor_point =
                      FEMap::inverse_map(neighbor->dim(), neighbor, physical, map_tolerance);
 
                    for (const auto i : index_range(dofs))
                      {
                        const auto it =
                          std::find(neighbor_dofs.begin(), neighbor_dofs.end(), dofs[i]);
                        if (it == neighbor_dofs.end())
                          continue;
 
                        const auto j = std::distance(neighbor_dofs.begin(), it);
 
                        LIBMESH_ASSERT_FP_EQUAL(
                          FEInterface::shape(fe_type, elem, i, point),
                          FEInterface::shape(fe_type, neighbor, j, neighbor_point),
                          TOLERANCE);
                        ++n_compared;
                      }
                  }
              }
          }
      }
 
    // Guard against a vacuous pass
    _mesh->comm().sum(n_compared);
    CPPUNIT_ASSERT(n_compared > 0);
  }

References FEOrientationTestBase< order, family >::_mesh, libMesh::EquationSystems::add_system(), libMesh::System::add_variable(), libMesh::Elem::dim(), libMesh::DofMap::dof_indices(), libMesh::System::get_dof_map(), libMesh::QBase::get_points(), libMesh::index_range(), libMesh::EquationSystems::init(), libMesh::QBase::init(), libMesh::FEMap::inverse_map(), libMesh::make_range(), libMesh::FEMap::map(), FEOrientationTestBase< order, family >::map_tolerance, FEOrientationTestBase< order, family >::n_rounds(), libMesh::Elem::neighbor_ptr(), libMesh::remote_elem, libMesh::FEInterface::shape(), and libMesh::TOLERANCE.

test_orientation_determines_shapes()

template<Order order, FEFamily family>

void FEOrientationTestBase< order, family >::test_orientation_determines_shapes ( )

inlineinherited

Definition at line 89 of file fe_orientation_test.C.

  {
    LOG_UNIT_TEST;
 
    const FEType fe_type(order, family);
 
    // Number of comparisons between repeat visits to an entity orientation
    unsigned int n_compared = 0;
 
    for (auto * elem : _mesh->active_local_element_ptr_range())
      {
        QGauss qrule(elem->dim(), order);
        qrule.init(*elem);
        const std::vector<Point> & points = qrule.get_points();
 
        // Shape function values seen, per entity and orientation index
        std::map<Entity, std::map<unsigned int, std::vector<Real>>> seen;
 
        // Permuting renumbers the vertices without moving them, cycling the entity orientations
        for (const auto p : make_range(elem->n_permutations()))
          {
            elem->permute(p);
 
            // Element degrees of freedom are numbered by node, then interior
            unsigned int dof = 0;
 
            for (const auto n : elem->node_index_range())
              {
                const unsigned int n_dofs = FEInterface::n_dofs_at_node(fe_type, elem, n);
                if (!n_dofs)
                  continue;
 
                record(seen[node_entity(*elem, n)],
                       entity_orientation(*elem, node_entity(*elem, n)),
                       shapes(fe_type, *elem, dof, n_dofs, points),
                       n_compared);
 
                dof += n_dofs;
              }
 
            const unsigned int n_interior = FEInterface::n_dofs_per_elem(fe_type, elem);
            if (n_interior)
              record(seen[{INTERIOR, 0}], 0,
                     shapes(fe_type, *elem, dof, n_interior, points), n_compared);
          }
      }
 
    // Guard against a vacuous pass
    _mesh->comm().sum(n_compared);
    CPPUNIT_ASSERT(n_compared > 0);
  }

References FEOrientationTestBase< order, family >::_mesh, FEOrientationTestBase< order, family >::entity_orientation(), libMesh::QBase::get_points(), libMesh::QBase::init(), INTERIOR, libMesh::make_range(), libMesh::FEInterface::n_dofs_at_node(), libMesh::FEInterface::n_dofs_per_elem(), FEOrientationTestBase< order, family >::node_entity(), FEOrientationTestBase< order, family >::record(), and FEOrientationTestBase< order, family >::shapes().

Member Data Documentation

_mesh

template<Order order, FEFamily family>

std::unique_ptr<Mesh> FEOrientationTestBase< order, family >::_mesh

protectedinherited

Definition at line 35 of file fe_orientation_test.C.

Referenced by FEOrientationTest< elem_type, order, family >::build_mesh(), FEHybridOrientationTest< order, family >::build_mesh(), FEOrientationTestBase< order, family >::n_rounds(), FEOrientationTestBase< order, family >::setUp(), FEOrientationTestBase< order, family >::tearDown(), FEOrientationTestBase< order, family >::test_conformity_across_sides(), and FEOrientationTestBase< order, family >::test_orientation_determines_shapes().

libmesh_suite_name

template<Order order, FEFamily family>

std::string FEOrientationTestBase< order, family >::libmesh_suite_name

protectedinherited

Definition at line 36 of file fe_orientation_test.C.

map_tolerance

template<Order order, FEFamily family>

constexpr Real FEOrientationTestBase< order, family >::map_tolerance = TOLERANCE * TOLERANCE

staticconstexprprivateinherited

The tolerance for inverse_map()

Definition at line 218 of file fe_orientation_test.C.

Referenced by FEOrientationTestBase< order, family >::test_conformity_across_sides().

---

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

• tests/fe/fe_orientation_test.C