fe_reference_element_traits.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2026 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
#ifndef LIBMESH_FE_REFERENCE_ELEMENT_TRAITS_H
#define LIBMESH_FE_REFERENCE_ELEMENT_TRAITS_H
 
#include "libmesh/libmesh.h" // invalid_uint
 
namespace libMesh
{
 
static constexpr unsigned int unused_side_node = 99;
 
template <unsigned int Rows, unsigned int Cols>
struct NodeMapTable
{
  unsigned int values[Rows][Cols];
};
 
constexpr unsigned int no_face_node (const unsigned int)
{
  return invalid_uint;
}
 
template <class FirstOrder, unsigned int Edges>
constexpr NodeMapTable<Edges, 3>
derived_edge_nodes ()
{
  NodeMapTable<Edges, 3> t {};
  for (unsigned int e = 0; e != Edges; ++e)
    {
      t.values[e][0] = FirstOrder::edge_nodes_map[e][0];
      t.values[e][1] = FirstOrder::edge_nodes_map[e][1];
      t.values[e][2] = FirstOrder::num_nodes + e;
    }
  return t;
}
 
template <class FirstOrder>
constexpr unsigned int n_side_vertices (const unsigned int s)
{
  unsigned int n = 0;
  for (unsigned int k = 0; k != FirstOrder::nodes_per_side; ++k)
    if (FirstOrder::side_nodes_map[s][k] != unused_side_node)
      ++n;
  return n;
}
 
template <unsigned int Edges>
constexpr unsigned int mid_edge_node (const unsigned int (&edges)[Edges][3],
                                      const unsigned int a,
                                      const unsigned int b)
{
  for (unsigned int e = 0; e != Edges; ++e)
    if ((edges[e][0] == a && edges[e][1] == b) ||
        (edges[e][0] == b && edges[e][1] == a))
      return edges[e][2];
  return invalid_uint;
}
 
template <class FirstOrder, unsigned int Sides, unsigned int Cols,
          unsigned int Edges, class FaceNode>
constexpr NodeMapTable<Sides, Cols>
derived_side_nodes (const unsigned int (&edges)[Edges][3],
                    FaceNode face_node)
{
  NodeMapTable<Sides, Cols> t {};
  for (unsigned int s = 0; s != Sides; ++s)
    {
      const unsigned int nv = n_side_vertices<FirstOrder>(s);
      unsigned int n = 0;
      for (unsigned int k = 0; k != nv; ++k)
        t.values[s][n++] = FirstOrder::side_nodes_map[s][k];
      for (unsigned int k = 0; k != nv; ++k)
        t.values[s][n++] = mid_edge_node(edges,
                                         FirstOrder::side_nodes_map[s][k],
                                         FirstOrder::side_nodes_map[s][(k+1) % nv]);
      if (face_node(s) != invalid_uint)
        t.values[s][n++] = face_node(s);
      for (; n != Cols; ++n)
        t.values[s][n] = unused_side_node;
    }
  return t;
}
 
template <class FirstOrder, unsigned int Sides>
constexpr NodeMapTable<Sides, 3>
derived_side_nodes ()
{
  NodeMapTable<Sides, 3> t {};
  for (unsigned int s = 0; s != Sides; ++s)
    {
      t.values[s][0] = FirstOrder::side_nodes_map[s][0];
      t.values[s][1] = FirstOrder::side_nodes_map[s][1];
      t.values[s][2] = FirstOrder::num_nodes + s;
    }
  return t;
}
 
} // namespace libMesh
 
#endif // LIBMESH_FE_REFERENCE_ELEMENT_TRAITS_H