MooseTypes.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "Moose.h"
#include "DualReal.h"
 
#include "libmesh/libmesh.h"
#include "libmesh/id_types.h"
#include "libmesh/stored_range.h"
#include "libmesh/petsc_macro.h"
#include "libmesh/boundary_info.h"
#include "libmesh/parameters.h"
 
// BOOST include
#include "bitmask_operators.h"
 
#include "libmesh/ignore_warnings.h"
#include "Eigen/Core"
#include "libmesh/restore_warnings.h"
#include "libmesh/tensor_tools.h"
 
#include <string>
#include <vector>
#include <memory>
#include <type_traits>
#include <functional>
 
// DO NOT USE (Deprecated)
#define MooseSharedPointer std::shared_ptr
#define MooseSharedNamespace std
 
// The multiple macros that you would need anyway [as per: Crazy Eddie (stack overflow)]
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
#endif
 
#define beginIndex_0() ERROR-- > "beginIndex() requires one or two arguments"
#define beginIndex_1(A) decltype(A.size())(0)
#define beginIndex_2(A, B) decltype(A.size())(B)
#define beginIndex_3(A, B, C) ERROR-- > "beginIndex() requires one or two arguments"
#define beginIndex_4(A, B, C, D) ERROR-- > "beginIndex() requires one or two arguments"
 
// The interim macro that simply strips the excess and ends up with the required macro
#define beginIndex_X(x, A, B, C, D, FUNC, ...) FUNC
 
// The macro that the programmer uses
#define beginIndex(...)                                                                            \
  beginIndex_X(,                                                                                   \
               ##__VA_ARGS__,                                                                      \
               beginIndex_4(__VA_ARGS__),                                                          \
               beginIndex_3(__VA_ARGS__),                                                          \
               beginIndex_2(__VA_ARGS__),                                                          \
               beginIndex_1(__VA_ARGS__),                                                          \
               beginIndex_0(__VA_ARGS__))
 
#define MooseIndex(type) decltype(_MooseIndex(type, 0))
 
// SFINAE templates for type MooseIndex type selection
template <typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
typename std::remove_const<T>::type
_MooseIndex(T, int)
{
}
 
template <typename T>
decltype(std::declval<T>().size())
_MooseIndex(T &&, int)
{
}
 
template <typename T>
decltype("NOTE: MooseIndex only works with integers and objects with size()!")
_MooseIndex(T, double) = delete;
 
#ifdef __clang__
#pragma clang diagnostic pop
#endif
 
template <typename>
class MooseArray;
template <typename>
class RankTwoTensorTempl;
typedef RankTwoTensorTempl<Real> RankTwoTensor;
typedef RankTwoTensorTempl<DualReal> DualRankTwoTensor;
template <typename>
class RankFourTensorTempl;
typedef RankFourTensorTempl<Real> RankFourTensor;
typedef RankFourTensorTempl<DualReal> DualRankFourTensor;
template <typename>
class MaterialProperty;
template <typename>
class ADMaterialPropertyObject;
class InputParameters;
 
namespace libMesh
{
template <typename>
class VectorValue;
typedef VectorValue<Real> RealVectorValue;
typedef Eigen::Matrix<Real, LIBMESH_DIM, 1> RealDIMValue;
typedef Eigen::Matrix<Real, Eigen::Dynamic, 1> RealEigenVector;
typedef Eigen::Matrix<Real, Eigen::Dynamic, LIBMESH_DIM> RealVectorArrayValue;
typedef Eigen::Matrix<Real, Eigen::Dynamic, LIBMESH_DIM * LIBMESH_DIM> RealTensorArrayValue;
typedef Eigen::Matrix<Real, Eigen::Dynamic, Eigen::Dynamic> RealEigenMatrix;
template <typename>
class TypeVector;
template <typename>
class TensorValue;
typedef TensorValue<Real> RealTensorValue;
template <typename>
class TypeTensor;
template <unsigned int, typename>
class TypeNTensor;
class Point;
template <typename>
class DenseMatrix;
template <typename>
class DenseVector;
 
namespace TensorTools
{
template <>
struct IncrementRank<Eigen::Matrix<Real, Eigen::Dynamic, 1>>
{
  typedef Eigen::Matrix<Real, Eigen::Dynamic, LIBMESH_DIM> type;
};
 
template <>
struct IncrementRank<Eigen::Matrix<Real, Eigen::Dynamic, LIBMESH_DIM>>
{
  typedef Eigen::Matrix<Real, Eigen::Dynamic, LIBMESH_DIM * LIBMESH_DIM> type;
};
 
template <>
struct DecrementRank<Eigen::Matrix<Real, Eigen::Dynamic, LIBMESH_DIM>>
{
  typedef Eigen::Matrix<Real, Eigen::Dynamic, 1> type;
};
}
}
 
#define ADReal typename Moose::RealType<compute_stage>::type
#define ADRealVectorValue typename RealVectorValueType<compute_stage>::type
#define ADPoint typename PointType<compute_stage>::type
#define ADRealTensorValue typename RealTensorValueType<compute_stage>::type
#define ADRankTwoTensor typename RankTwoTensorType<compute_stage>::type
#define ADRankFourTensor typename RankFourTensorType<compute_stage>::type
#define ADDenseMatrix typename DenseMatrixType<compute_stage>::type
#define ADDenseVector typename DenseVectorType<compute_stage>::type
 
typedef Real PostprocessorValue;
typedef std::vector<Real> VectorPostprocessorValue;
typedef Real ScatterVectorPostprocessorValue;
typedef boundary_id_type BoundaryID;
typedef unsigned int InterfaceID;
typedef subdomain_id_type SubdomainID;
typedef unsigned int MooseObjectID;
typedef unsigned int THREAD_ID;
typedef unsigned int TagID;
typedef unsigned int PerfID;
 
typedef StoredRange<std::vector<dof_id_type>::iterator, dof_id_type> NodeIdRange;
typedef StoredRange<std::vector<const Elem *>::iterator, const Elem *> ConstElemPointerRange;
 
enum ComputeStage
{
  RESIDUAL,
  JACOBIAN
};
 
namespace Moose
{
template <ComputeStage compute_stage>
struct RealType
{
  typedef Real type;
};
template <>
struct RealType<JACOBIAN>
{
  typedef DualReal type;
};
 
template <typename T, ComputeStage compute_stage>
struct ValueType
{
  typedef typename RealType<compute_stage>::type type;
};
 
template <ComputeStage compute_stage>
struct ValueType<Real, compute_stage>
{
  typedef typename RealType<compute_stage>::type type;
};
 
template <ComputeStage compute_stage, template <typename> class W>
struct ValueType<W<Real>, compute_stage>
{
  typedef W<typename RealType<compute_stage>::type> type;
};
 
template <typename OutputType>
struct ShapeType
{
  typedef OutputType type;
};
template <>
struct ShapeType<Eigen::Matrix<Real, Eigen::Dynamic, 1>>
{
  typedef Real type;
};
 
template <typename OutputType>
struct DOFType
{
  typedef OutputType type;
};
template <>
struct DOFType<RealVectorValue>
{
  typedef Real type;
};
} // MOOSE
 
template <typename OutputType>
struct OutputTools
{
  typedef typename TensorTools::IncrementRank<OutputType>::type OutputGradient;
  typedef typename TensorTools::IncrementRank<OutputGradient>::type OutputSecond;
  typedef typename TensorTools::DecrementRank<OutputType>::type OutputDivergence;
 
  typedef MooseArray<OutputType> VariableValue;
  typedef MooseArray<OutputGradient> VariableGradient;
  typedef MooseArray<OutputSecond> VariableSecond;
  typedef MooseArray<OutputType> VariableCurl;
  typedef MooseArray<OutputDivergence> VariableDivergence;
 
  typedef typename Moose::ShapeType<OutputType>::type OutputShape;
  typedef typename TensorTools::IncrementRank<OutputShape>::type OutputShapeGradient;
  typedef typename TensorTools::IncrementRank<OutputShapeGradient>::type OutputShapeSecond;
  typedef typename TensorTools::DecrementRank<OutputShape>::type OutputShapeDivergence;
 
  typedef MooseArray<std::vector<OutputShape>> VariablePhiValue;
  typedef MooseArray<std::vector<OutputShapeGradient>> VariablePhiGradient;
  typedef MooseArray<std::vector<OutputShapeSecond>> VariablePhiSecond;
  typedef MooseArray<std::vector<OutputShape>> VariablePhiCurl;
  typedef MooseArray<std::vector<OutputShapeDivergence>> VariablePhiDivergence;
 
  typedef MooseArray<std::vector<OutputShape>> VariableTestValue;
  typedef MooseArray<std::vector<OutputShapeGradient>> VariableTestGradient;
  typedef MooseArray<std::vector<OutputShapeSecond>> VariableTestSecond;
  typedef MooseArray<std::vector<OutputShape>> VariableTestCurl;
  typedef MooseArray<std::vector<OutputShapeDivergence>> VariableTestDivergence;
 
  // DoF value type for the template class OutputType
  typedef typename Moose::DOFType<OutputType>::type OutputData;
  typedef MooseArray<OutputData> DoFValue;
  typedef OutputType OutputValue;
};
 
// types for standard variable
typedef typename OutputTools<Real>::VariableValue VariableValue;
typedef typename OutputTools<Real>::VariableGradient VariableGradient;
typedef typename OutputTools<Real>::VariableSecond VariableSecond;
typedef typename OutputTools<Real>::VariableCurl VariableCurl;
typedef typename OutputTools<Real>::VariablePhiValue VariablePhiValue;
typedef typename OutputTools<Real>::VariablePhiGradient VariablePhiGradient;
typedef typename OutputTools<Real>::VariablePhiSecond VariablePhiSecond;
typedef typename OutputTools<Real>::VariablePhiCurl VariablePhiCurl;
typedef typename OutputTools<Real>::VariableTestValue VariableTestValue;
typedef typename OutputTools<Real>::VariableTestGradient VariableTestGradient;
typedef typename OutputTools<Real>::VariableTestSecond VariableTestSecond;
typedef typename OutputTools<Real>::VariableTestCurl VariableTestCurl;
 
// types for vector variable
typedef typename OutputTools<RealVectorValue>::VariableValue VectorVariableValue;
typedef typename OutputTools<RealVectorValue>::VariableGradient VectorVariableGradient;
typedef typename OutputTools<RealVectorValue>::VariableSecond VectorVariableSecond;
typedef typename OutputTools<RealVectorValue>::VariableCurl VectorVariableCurl;
typedef typename OutputTools<RealVectorValue>::VariablePhiValue VectorVariablePhiValue;
typedef typename OutputTools<RealVectorValue>::VariablePhiGradient VectorVariablePhiGradient;
typedef typename OutputTools<RealVectorValue>::VariablePhiSecond VectorVariablePhiSecond;
typedef typename OutputTools<RealVectorValue>::VariablePhiCurl VectorVariablePhiCurl;
typedef typename OutputTools<RealVectorValue>::VariableTestValue VectorVariableTestValue;
typedef typename OutputTools<RealVectorValue>::VariableTestGradient VectorVariableTestGradient;
typedef typename OutputTools<RealVectorValue>::VariableTestSecond VectorVariableTestSecond;
typedef typename OutputTools<RealVectorValue>::VariableTestCurl VectorVariableTestCurl;
 
// types for array variable
typedef typename OutputTools<RealEigenVector>::VariableValue ArrayVariableValue;
typedef typename OutputTools<RealEigenVector>::VariableGradient ArrayVariableGradient;
typedef typename OutputTools<RealEigenVector>::VariableSecond ArrayVariableSecond;
typedef typename OutputTools<RealEigenVector>::VariableCurl ArrayVariableCurl;
typedef typename OutputTools<RealEigenVector>::VariablePhiValue ArrayVariablePhiValue;
typedef typename OutputTools<RealEigenVector>::VariablePhiGradient ArrayVariablePhiGradient;
typedef std::vector<std::vector<Eigen::Map<RealDIMValue>>> MappedArrayVariablePhiGradient;
typedef typename OutputTools<RealEigenVector>::VariablePhiSecond ArrayVariablePhiSecond;
typedef typename OutputTools<RealEigenVector>::VariablePhiCurl ArrayVariablePhiCurl;
typedef typename OutputTools<RealEigenVector>::VariableTestValue ArrayVariableTestValue;
typedef typename OutputTools<RealEigenVector>::VariableTestGradient ArrayVariableTestGradient;
typedef typename OutputTools<RealEigenVector>::VariableTestSecond ArrayVariableTestSecond;
typedef typename OutputTools<RealEigenVector>::VariableTestCurl ArrayVariableTestCurl;
 
template <template <class> class W>
using TemplateDN = W<DualReal>;
 
typedef TemplateDN<VectorValue> DualRealVectorValue;
typedef TemplateDN<TensorValue> DualRealTensorValue;
 
typedef DualRealVectorValue DualRealGradient;
typedef DualRealTensorValue ADRealTensor;
 
template <typename T, ComputeStage compute_stage>
struct VariableValueType
{
  typedef
      typename OutputTools<typename Moose::ValueType<T, compute_stage>::type>::VariableValue type;
};
typedef typename VariableValueType<Real, ComputeStage::JACOBIAN>::type DualVariableValue;
 
template <typename T, ComputeStage compute_stage>
struct VariableGradientType
{
  typedef typename OutputTools<typename Moose::ValueType<T, compute_stage>::type>::VariableGradient
      type;
};
template <typename T, ComputeStage compute_stage>
struct VariableTestGradientType
{
  typedef
      typename OutputTools<typename Moose::ValueType<T, compute_stage>::type>::VariableTestGradient
          type;
};
template <typename T, ComputeStage compute_stage>
struct VariableSecondType
{
  typedef
      typename OutputTools<typename Moose::ValueType<T, compute_stage>::type>::VariableSecond type;
};
template <typename T, ComputeStage compute_stage>
struct VariablePhiGradientType
{
  typedef
      typename OutputTools<typename Moose::ValueType<T, compute_stage>::type>::VariablePhiGradient
          type;
};
 
template <ComputeStage compute_stage>
struct RealVectorValueType
{
  typedef RealVectorValue type;
};
template <>
struct RealVectorValueType<JACOBIAN>
{
  typedef DualRealVectorValue type;
};
template <ComputeStage compute_stage>
struct RealTensorValueType
{
  typedef RealTensorValue type;
};
template <>
struct RealTensorValueType<JACOBIAN>
{
  typedef DualRealTensorValue type;
};
template <ComputeStage compute_stage>
struct RankTwoTensorType
{
  typedef RankTwoTensor type;
};
template <>
struct RankTwoTensorType<JACOBIAN>
{
  typedef DualRankTwoTensor type;
};
template <ComputeStage compute_stage>
struct RankFourTensorType
{
  typedef RankFourTensor type;
};
template <>
struct RankFourTensorType<JACOBIAN>
{
  typedef DualRankFourTensor type;
};
template <ComputeStage compute_stage>
struct DenseMatrixType
{
  typedef DenseMatrix<Real> type;
};
template <>
struct DenseMatrixType<JACOBIAN>
{
  typedef DenseMatrix<DualReal> type;
};
template <ComputeStage compute_stage>
struct DenseVectorType
{
  typedef DenseVector<Real> type;
};
template <>
struct DenseVectorType<JACOBIAN>
{
  typedef DenseVector<DualReal> type;
};
 
template <typename mat_prop_type, ComputeStage compute_stage>
struct MaterialPropertyType
{
  typedef MaterialProperty<mat_prop_type> type;
};
template <typename mat_prop_type>
struct MaterialPropertyType<mat_prop_type, JACOBIAN>
{
  typedef ADMaterialPropertyObject<mat_prop_type> type;
};
 
template <ComputeStage compute_stage>
struct PointType
{
  typedef MooseArray<Point> type;
};
template <>
struct PointType<JACOBIAN>
{
  typedef MooseArray<VectorValue<DualReal>> type;
};
 
#define ADVariableValue typename VariableValueType<Real, compute_stage>::type
#define ADVariableGradient typename VariableGradientType<Real, compute_stage>::type
#define ADVariableSecond typename VariableSecondType<Real, compute_stage>::type
 
#define ADVectorVariableValue typename VariableValueType<RealVectorValue, compute_stage>::type
#define ADVectorVariableGradient typename VariableGradientType<RealVectorValue, compute_stage>::type
#define ADVectorVariableSecond typename VariableSecondType<RealVectorValue, compute_stage>::type
 
#define ADTemplateVariableValue typename VariableValueType<T, compute_stage>::type
#define ADTemplateVariableGradient typename VariableGradientType<T, compute_stage>::type
#define ADTemplateVariableSecond typename VariableSecondType<T, compute_stage>::type
 
#define ADTemplateVariablePhiGradient typename VariablePhiGradientType<T, compute_stage>::type
#define ADVariablePhiGradient typename VariablePhiGradientType<Real, compute_stage>::type
 
#define ADMaterialProperty(Type) typename MaterialPropertyType<Type, compute_stage>::type
 
typedef VariableTestValue ADVariableTestValue;
typedef VariableTestGradient ADVariableTestGradient;
typedef VariableTestSecond ADVariableTestSecond;
typedef VectorVariableTestValue ADVectorVariableTestValue;
typedef VectorVariableTestGradient ADVectorVariableTestGradient;
typedef VectorVariableTestSecond ADVectorVariableTestSecond;
#define ADTemplateVariableTestValue typename OutputTools<T>::VariableTestValue
#define ADTemplateVariableTestSecond typename OutputTools<T>::VariableTestSecond
#define ADTemplateVariablePhiValue typename OutputTools<T>::VariablePhiValue
 
#define declareADValidParams(ADObjectType)                                                         \
  template <>                                                                                      \
  InputParameters validParams<ADObjectType<RESIDUAL>>();                                           \
  template <>                                                                                      \
  InputParameters validParams<ADObjectType<JACOBIAN>>()
 
#define defineADValidParams(ADObjectType, ADBaseObjectType, addedParamCode)                        \
  template <>                                                                                      \
  InputParameters validParams<ADObjectType<RESIDUAL>>()                                            \
  {                                                                                                \
    InputParameters params = validParams<ADBaseObjectType<RESIDUAL>>();                            \
    addedParamCode;                                                                                \
    return params;                                                                                 \
  }                                                                                                \
  template <>                                                                                      \
  InputParameters validParams<ADObjectType<JACOBIAN>>()                                            \
  {                                                                                                \
    return validParams<ADObjectType<RESIDUAL>>();                                                  \
  }                                                                                                \
  void mooseClangFormatFunction()
 
#define defineLegacyParams(ObjectType)                                                             \
  template <>                                                                                      \
  InputParameters validParams<ObjectType>()                                                        \
  {                                                                                                \
    return ObjectType::validParams();                                                              \
  }                                                                                                \
  void mooseClangFormatFunction()
 
#define defineADLegacyParams(ADObjectType)                                                         \
  template <>                                                                                      \
  InputParameters validParams<ADObjectType<RESIDUAL>>()                                            \
  {                                                                                                \
    return ADObjectType<RESIDUAL>::validParams();                                                  \
  }                                                                                                \
  template <>                                                                                      \
  InputParameters validParams<ADObjectType<JACOBIAN>>()                                            \
  {                                                                                                \
    return ADObjectType<JACOBIAN>::validParams();                                                  \
  }                                                                                                \
  void mooseClangFormatFunction()
 
#define defineADBaseValidParams(ADObjectType, BaseObjectType, addedParamCode)                      \
  template <>                                                                                      \
  InputParameters validParams<ADObjectType<RESIDUAL>>()                                            \
  {                                                                                                \
    InputParameters params = validParams<BaseObjectType>();                                        \
    addedParamCode;                                                                                \
    return params;                                                                                 \
  }                                                                                                \
  template <>                                                                                      \
  InputParameters validParams<ADObjectType<JACOBIAN>>()                                            \
  {                                                                                                \
    return validParams<ADObjectType<RESIDUAL>>();                                                  \
  }                                                                                                \
  void mooseClangFormatFunction()
 
#define defineADValidParamsFromEmpty(ADObjectType, addedParamCode)                                 \
  template <>                                                                                      \
  InputParameters validParams<ADObjectType<RESIDUAL>>()                                            \
  {                                                                                                \
    InputParameters params = emptyInputParameters();                                               \
    addedParamCode;                                                                                \
    return params;                                                                                 \
  }                                                                                                \
  template <>                                                                                      \
  InputParameters validParams<ADObjectType<JACOBIAN>>()                                            \
  {                                                                                                \
    return validParams<ADObjectType<RESIDUAL>>();                                                  \
  }                                                                                                \
  void mooseClangFormatFunction()
 
namespace Moose
{
extern const processor_id_type INVALID_PROCESSOR_ID;
extern const SubdomainID ANY_BLOCK_ID;
extern const SubdomainID INVALID_BLOCK_ID;
extern const BoundaryID ANY_BOUNDARY_ID;
extern const BoundaryID INVALID_BOUNDARY_ID;
const std::set<SubdomainID> EMPTY_BLOCK_IDS = {};
const std::set<BoundaryID> EMPTY_BOUNDARY_IDS = {};
 
enum MaterialDataType
{
  BLOCK_MATERIAL_DATA,
  BOUNDARY_MATERIAL_DATA,
  FACE_MATERIAL_DATA,
  NEIGHBOR_MATERIAL_DATA,
  INTERFACE_MATERIAL_DATA
};
 
enum AuxGroup
{
  PRE_IC = 0,
  PRE_AUX = 1,
  POST_AUX = 2,
  ALL = 3
};
 
enum VarKindType
{
  VAR_NONLINEAR,
  VAR_AUXILIARY,
  VAR_ANY
};
 
enum VarFieldType
{
  VAR_FIELD_STANDARD,
  VAR_FIELD_SCALAR,
  VAR_FIELD_VECTOR,
  VAR_FIELD_ARRAY,
  VAR_FIELD_ANY
};
 
enum CouplingType
{
  COUPLING_DIAG,
  COUPLING_FULL,
  COUPLING_CUSTOM
};
 
enum ConstraintSideType
{
  SIDE_MASTER,
  SIDE_SLAVE
};
 
enum DGResidualType
{
  Element,
  Neighbor
};
 
enum DGJacobianType
{
  ElementElement,
  ElementNeighbor,
  NeighborElement,
  NeighborNeighbor
};
 
enum ConstraintType
{
  Slave = Element,
  Master = Neighbor
};
 
enum class ElementType : unsigned int
{
  Element = DGResidualType::Element,
  Neighbor = DGResidualType::Neighbor,
  Lower = DGResidualType::Neighbor + 1
};
 
enum class MortarType : unsigned int
{
  Slave = static_cast<unsigned int>(Moose::ElementType::Element),
  Master = static_cast<unsigned int>(Moose::ElementType::Neighbor),
  Lower = static_cast<unsigned int>(Moose::ElementType::Lower)
};
 
enum class RESTARTABLE_FILTER : unsigned char
{
  RECOVERABLE
};
 
enum ConstraintJacobianType
{
  SlaveSlave = ElementElement,
  SlaveMaster = ElementNeighbor,
  MasterSlave = NeighborElement,
  MasterMaster = NeighborNeighbor,
  LowerLower,
  LowerSlave,
  LowerMaster,
  SlaveLower,
  MasterLower
};
 
enum CoordinateSystemType
{
  COORD_XYZ,
  COORD_RZ,
  COORD_RSPHERICAL
};
 
enum PCSideType
{
  PCS_LEFT,
  PCS_RIGHT,
  PCS_SYMMETRIC,
  PCS_DEFAULT 
};
 
enum MooseKSPNormType
{
  KSPN_NONE,
  KSPN_PRECONDITIONED,
  KSPN_UNPRECONDITIONED,
  KSPN_NATURAL,
  KSPN_DEFAULT 
};
 
enum SolveType
{
  ST_PJFNK,  
  ST_JFNK,   
  ST_NEWTON, 
  ST_FD,     
  ST_LINEAR  
};
 
enum EigenSolveType
{
  EST_POWER,              
  EST_ARNOLDI,            
  EST_KRYLOVSCHUR,        
  EST_JACOBI_DAVIDSON,    
  EST_NONLINEAR_POWER,    
  EST_MF_NONLINEAR_POWER, 
  EST_MONOLITH_NEWTON,    
  EST_MF_MONOLITH_NEWTON, 
};
 
enum EigenProblemType
{
  EPT_HERMITIAN,             
  EPT_NON_HERMITIAN,         
  EPT_GEN_HERMITIAN,         
  EPT_GEN_INDEFINITE,        
  EPT_GEN_NON_HERMITIAN,     
  EPT_POS_GEN_NON_HERMITIAN, 
  EPT_SLEPC_DEFAULT          
};
 
enum WhichEigenPairs
{
  WEP_LARGEST_MAGNITUDE,  
  WEP_SMALLEST_MAGNITUDE, 
  WEP_LARGEST_REAL,       
  WEP_SMALLEST_REAL,      
  WEP_LARGEST_IMAGINARY,  
  WEP_SMALLEST_IMAGINARY, 
  WEP_TARGET_MAGNITUDE,   
  WEP_TARGET_REAL,        
  WEP_TARGET_IMAGINARY,   
  WEP_ALL_EIGENVALUES,    
  WEP_SLEPC_DEFAULT       
};
 
enum TimeIntegratorType
{
  TI_IMPLICIT_EULER,
  TI_EXPLICIT_EULER,
  TI_CRANK_NICOLSON,
  TI_BDF2,
  TI_EXPLICIT_MIDPOINT,
  TI_LSTABLE_DIRK2,
  TI_EXPLICIT_TVD_RK_2,
  TI_NEWMARK_BETA
};
 
enum ConstraintFormulationType
{
  Penalty,
  Kinematic
};
enum LineSearchType
{
  LS_INVALID, 
  LS_DEFAULT,
  LS_NONE,
  LS_BASIC,
#ifdef LIBMESH_HAVE_PETSC
#if PETSC_VERSION_LESS_THAN(3, 3, 0)
  LS_CUBIC,
  LS_QUADRATIC,
  LS_BASICNONORMS,
#else
  LS_SHELL,
  LS_CONTACT,
  LS_PROJECT,
  LS_L2,
  LS_BT,
  LS_CP
#endif
#endif
};
 
enum MffdType
{
  MFFD_INVALID, 
  MFFD_WP,
  MFFD_DS
};
 
enum PatchUpdateType
{
  Never,
  Always,
  Auto,
  Iteration
};
 
enum class RelationshipManagerType : unsigned char
{
  DEFAULT = 0,
  GEOMETRIC = 1 << 0,
  ALGEBRAIC = 1 << 1,
  COUPLING = 1 << 2
};
 
enum RMSystemType
{
  NONLINEAR,
  AUXILIARY,
  NONE
};
 
typedef std::function<void(const InputParameters &, InputParameters &)>
    RelationshipManagerInputParameterCallback;
 
std::string stringify(const Moose::RelationshipManagerType & t);
} // namespace Moose
 
namespace libMesh
{
template <>
inline void
print_helper(std::ostream & os, const Moose::RelationshipManagerType * param)
{
  // Specialization so that we don't print out unprintable characters
  os << Moose::stringify(*param);
}
 
// End of Moose Namespace
}
 
template <>
struct enable_bitmask_operators<Moose::RelationshipManagerType>
{
  static const bool enable = true;
};
 
#define DerivativeStringClass(TheName)                                                             \
  class TheName : public std::string                                                               \
  {                                                                                                \
  public:                                                                                          \
    TheName() : std::string() {}                                                                   \
    TheName(const std::string & str) : std::string(str) {}                                         \
    TheName(const std::string & str, size_t pos, size_t n = npos) : std::string(str, pos, n) {}    \
    TheName(const char * s, size_t n) : std::string(s, n) {}                                       \
    TheName(const char * s) : std::string(s) {}                                                    \
    TheName(size_t n, char c) : std::string(n, c) {}                                               \
  } /* No semicolon here because this is a macro */
 
// Instantiate new Types
 
DerivativeStringClass(FileName);
 
DerivativeStringClass(FileNameNoExtension);
 
DerivativeStringClass(MeshFileName);
 
DerivativeStringClass(OutFileBase);
 
DerivativeStringClass(NonlinearVariableName);
 
DerivativeStringClass(AuxVariableName);
 
DerivativeStringClass(VariableName);
 
DerivativeStringClass(BoundaryName);
 
DerivativeStringClass(SubdomainName);
 
DerivativeStringClass(PostprocessorName);
 
DerivativeStringClass(VectorPostprocessorName);
 
DerivativeStringClass(FunctionName);
 
DerivativeStringClass(DistributionName);
 
DerivativeStringClass(SamplerName);
 
DerivativeStringClass(UserObjectName);
 
DerivativeStringClass(IndicatorName);
 
DerivativeStringClass(MarkerName);
 
DerivativeStringClass(MultiAppName);
 
DerivativeStringClass(OutputName);
 
DerivativeStringClass(MaterialPropertyName);
 
DerivativeStringClass(MaterialName);
 
DerivativeStringClass(TagName);
 
DerivativeStringClass(MeshGeneratorName);
 
DerivativeStringClass(ExtraElementIDName);