fe_type.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_TYPE_H
#define LIBMESH_FE_TYPE_H
 
// Local includes
#include "libmesh/compare_types.h"
#include "libmesh/libmesh_config.h"
#include "libmesh/enum_order.h" // return Order objects
#include "libmesh/enum_fe_family.h" // LAGRANGE
#include "libmesh/enum_inf_map_type.h" // CARTESIAN
#include "libmesh/hashing.h"
 
// C++ includes
#include <memory>
#include <functional>
 
namespace libMesh
{
 
// Forward declarations
class QBase;
class FEType;
 
class OrderWrapper
{
public:
 
  OrderWrapper(Order order) :
    _order(static_cast<int>(order))
  {}
 
  OrderWrapper(int order) :
    _order(order)
  {}
 
  operator Order() const
  {
    return static_cast<Order>(_order);
  }
 
  int get_order() const
  {
    return _order;
  }
 
  template <typename T>
  inline OrderWrapper & operator+=(T p)
  {
    _order += int(p);
    return *this;
  }
 
  template <typename T>
  inline OrderWrapper & operator-=(T p)
  {
    _order -= int(p);
    return *this;
  }
 
private:
 
  int _order;
 
  friend struct std::hash<FEType>;
};
 
inline bool operator==(const OrderWrapper & lhs, const OrderWrapper & rhs){ return lhs.get_order() == rhs.get_order(); }
inline bool operator!=(const OrderWrapper & lhs, const OrderWrapper & rhs){ return !(lhs == rhs); }
inline bool operator< (const OrderWrapper & lhs, const OrderWrapper & rhs){ return lhs.get_order() < rhs.get_order(); }
inline bool operator> (const OrderWrapper & lhs, const OrderWrapper & rhs){ return rhs < lhs; }
inline bool operator<=(const OrderWrapper & lhs, const OrderWrapper & rhs){ return !(lhs > rhs); }
inline bool operator>=(const OrderWrapper & lhs, const OrderWrapper & rhs){ return !(lhs < rhs); }
 
// First disambiguate everything that would be ambiguated by the
// subsequent disambiguations
#define OrderWrapperOperators(comparisontype)           \
  inline bool operator==(comparisontype lhs, Order rhs) \
  { return lhs == static_cast<comparisontype>(rhs); }   \
  inline bool operator==(Order lhs, comparisontype rhs) \
  { return static_cast<comparisontype>(lhs) == rhs; }   \
  inline bool operator!=(comparisontype lhs, Order rhs) \
  { return !(lhs == rhs); }                             \
  inline bool operator!=(Order lhs, comparisontype rhs) \
  { return !(lhs == rhs); }                             \
  inline bool operator< (comparisontype lhs, Order rhs) \
  { return lhs < static_cast<comparisontype>(rhs); }    \
  inline bool operator< (Order lhs, comparisontype rhs) \
  { return static_cast<comparisontype>(lhs) < rhs; }    \
  inline bool operator> (comparisontype lhs, Order rhs) \
  { return rhs < lhs; }                                 \
  inline bool operator> (Order lhs, comparisontype rhs) \
  { return rhs < lhs; }                                 \
  inline bool operator<=(comparisontype lhs, Order rhs) \
  { return !(lhs > rhs); }                              \
  inline bool operator<=(Order lhs, comparisontype rhs) \
  { return !(lhs > rhs); }                              \
  inline bool operator>=(comparisontype lhs, Order rhs) \
  { return !(lhs < rhs); }                              \
  inline bool operator>=(Order lhs, comparisontype rhs) \
  { return !(lhs < rhs); }
 
OrderWrapperOperators(int)
OrderWrapperOperators(unsigned int)
#if LIBMESH_SIZEOF_SIZE_T != LIBMESH_SIZEOF_UNSIGNED_INT
OrderWrapperOperators(std::size_t)
#endif
 
// Now disambiguate all the things
inline bool operator==(int lhs, const OrderWrapper & rhs){ return lhs == rhs.get_order(); }
inline bool operator==(const OrderWrapper & lhs, int rhs){ return lhs.get_order() == rhs; }
inline bool operator==(Order lhs, const OrderWrapper & rhs){ return lhs == rhs.get_order(); }
inline bool operator==(const OrderWrapper & lhs, Order rhs){ return lhs.get_order() == rhs; }
inline bool operator!=(int lhs, const OrderWrapper & rhs){ return !(lhs == rhs); }
inline bool operator!=(const OrderWrapper & lhs, int rhs){ return !(lhs == rhs); }
inline bool operator!=(Order lhs, const OrderWrapper & rhs){ return !(lhs == rhs); }
inline bool operator!=(const OrderWrapper & lhs, Order rhs){ return !(lhs == rhs); }
inline bool operator< (int lhs, const OrderWrapper & rhs){ return lhs < rhs.get_order(); }
inline bool operator< (const OrderWrapper & lhs, int rhs){ return lhs.get_order() < rhs; }
inline bool operator< (Order lhs, const OrderWrapper & rhs){ return lhs < rhs.get_order(); }
inline bool operator< (const OrderWrapper & lhs, Order rhs){ return lhs.get_order() < rhs; }
inline bool operator> (int lhs, const OrderWrapper & rhs){ return rhs < lhs; }
inline bool operator> (const OrderWrapper & lhs, int rhs){ return rhs < lhs; }
inline bool operator> (Order lhs, const OrderWrapper & rhs){ return rhs < lhs; }
inline bool operator> (const OrderWrapper & lhs, Order rhs){ return rhs < lhs; }
inline bool operator<=(int lhs, const OrderWrapper & rhs){ return !(lhs > rhs); }
inline bool operator<=(const OrderWrapper & lhs, int rhs){ return !(lhs > rhs); }
inline bool operator<=(Order lhs, const OrderWrapper & rhs){ return !(lhs > rhs); }
inline bool operator<=(const OrderWrapper & lhs, Order rhs){ return !(lhs > rhs); }
inline bool operator>=(int lhs, const OrderWrapper & rhs){ return !(lhs < rhs); }
inline bool operator>=(const OrderWrapper & lhs, int rhs){ return !(lhs < rhs); }
inline bool operator>=(Order lhs, const OrderWrapper & rhs){ return !(lhs < rhs); }
inline bool operator>=(const OrderWrapper & lhs, Order rhs){ return !(lhs < rhs); }
 
inline std::ostream & operator << (std::ostream & os, const OrderWrapper & order)
{
  os << order.get_order();
  return os;
}
 
class FEType
{
public:
 
  OrderWrapper order;
 
#ifndef LIBMESH_ENABLE_INFINITE_ELEMENTS
 
  FEType(const int      o = 1,
         const FEFamily f = LAGRANGE) :
    order(o),
    family(f),
    p_refinement(true)
  {}
 
  FEFamily family;
 
#else
 
  FEType(const int        o  = 1,
         const FEFamily   f  = LAGRANGE,
         const int        ro = THIRD,
         const FEFamily   rf = JACOBI_20_00,
         const InfMapType im = CARTESIAN
         ) :
    order(o),
    radial_order(ro),
    family(f),
    radial_family(rf),
    inf_map(im),
    p_refinement(true)
  {}
 
  OrderWrapper radial_order;
 
  FEFamily family;
 
  FEFamily radial_family;
 
  InfMapType inf_map;
 
#endif // ifndef LIBMESH_ENABLE_INFINITE_ELEMENTS
 
  bool p_refinement;
 
  FEType set_p_refinement(bool p) &
  {
    this->p_refinement = p;
    return *this;
  }
 
  FEType set_p_refinement(bool p) &&
  {
    this->p_refinement = p;
    return std::move(*this);
  }
 
  bool operator== (const FEType & f2) const
  {
    return (order == f2.order
            && family == f2.family
            && p_refinement == f2.p_refinement
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
            && radial_order == f2.radial_order
            && radial_family == f2.radial_family
            && inf_map == f2.inf_map
#endif // ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
            );
  }
 
  bool operator!= (const FEType & f2) const
  {
    return !(*this == f2);
  }
 
  bool operator< (const FEType & f2) const
  {
    if (order != f2.order)
      return (order < f2.order);
    if (family != f2.family)
      return (family < f2.family);
    if (p_refinement != f2.p_refinement)
      return (p_refinement < f2.p_refinement);
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
    if (radial_order != f2.radial_order)
      return (radial_order < f2.radial_order);
    if (radial_family != f2.radial_family)
      return (radial_family < f2.radial_family);
    if (inf_map != f2.inf_map)
      return (inf_map < f2.inf_map);
#endif // ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
    return false;
  }
 
  Order default_quadrature_order () const;
 
  std::unique_ptr<QBase> default_quadrature_rule (const unsigned int dim,
                                                  const int extraorder=0) const;
 
  Order unweighted_quadrature_order () const;
 
  std::unique_ptr<QBase> unweighted_quadrature_rule (const unsigned int dim,
                                                     const int extraorder=0) const;
 
 
private:
 
};
 
 
 
//-------------------------------------------------------------------
// FEType inline methods
inline
Order FEType::default_quadrature_order () const
{
  return static_cast<Order>(2*static_cast<unsigned int>(order.get_order()) + 1);
}
 
inline
Order FEType::unweighted_quadrature_order () const
{
  return order;
}
 
} // namespace libMesh
 
namespace std
{
template <>
struct hash<libMesh::FEType>
{
  std::size_t operator()(const libMesh::FEType & fe_type) const
    {
      std::size_t seed = 0;
      // Old compiler versions seem to need the static_cast
      libMesh::boostcopy::hash_combine(seed, static_cast<int>(fe_type.family));
      libMesh::boostcopy::hash_combine(seed, fe_type.order._order);
      libMesh::boostcopy::hash_combine(seed, static_cast<int>(fe_type.p_refinement));
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
      libMesh::boostcopy::hash_combine(seed, static_cast<int>(fe_type.radial_family));
      libMesh::boostcopy::hash_combine(seed, fe_type.radial_order._order);
      libMesh::boostcopy::hash_combine(seed, static_cast<int>(fe_type.inf_map));
#endif // ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
     return seed;
    }
};
}
 
#endif // LIBMESH_FE_TYPE_H