fe_type.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2025 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:

#ifndef LIBMESH_ENABLE_INFINITE_ELEMENTS

  FEType(const int      o = 1,
         const FEFamily f = LAGRANGE) :
    order(o),
    family(f)
  {}

  OrderWrapper order;

  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)
  {}

  OrderWrapper order;

  OrderWrapper radial_order;

  FEFamily family;

  FEFamily radial_family;

  InfMapType inf_map;

#endif // ifndef LIBMESH_ENABLE_INFINITE_ELEMENTS

  bool operator== (const FEType & f2) const
  {
    return (order == f2.order
            && family == f2.family
#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);

#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);
      return seed;
    }
};
}

#endif // LIBMESH_FE_TYPE_H