MooseTypes.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* 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 "ADReal.h"
#include "EigenADReal.h"
#include "ChainedReal.h"
#include "ChainedADReal.h"
#include "ADRankTwoTensorForward.h"
#include "ADRankThreeTensorForward.h"
#include "ADRankFourTensorForward.h"
#include "ADSymmetricRankTwoTensorForward.h"
#include "ADSymmetricRankFourTensorForward.h"
 
// This is not strictly needed here, but it used to be included by ADReal.h
// so developers relied heavily on it being already available
#include "MooseError.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"
#include "libmesh/dense_vector.h"
#include "libmesh/dense_matrix.h"
#include "libmesh/int_range.h"
 
// BOOST include
#include "boost/bitmask_operators.h"
 
#include "libmesh/ignore_warnings.h"
#include "Eigen/Core"
#include "libmesh/restore_warnings.h"
#include "libmesh/tensor_tools.h"
 
#include "metaphysicl/ct_types.h"
 
#include <string>
#include <vector>
#include <memory>
#include <type_traits>
#include <functional>
#include <iterator> // std::data
 
#if !defined(INCLUDE_NLOHMANN_JSON_HPP_) && !defined(MOOSE_NLOHMANN_INCLUDED)
#undef INCLUDE_NLOHMANN_JSON_FWD_HPP_
#include "nlohmann/json_fwd.h"
#define MOOSE_NLOHMANN_INCLUDED
#endif
 
// 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 MaterialProperty;
template <typename>
class ADMaterialProperty;
class InputParameters;
 
namespace libMesh
{
typedef VectorValue<Real> RealVectorValue;
typedef Eigen::Matrix<Real, Moose::dim, 1> RealDIMValue;
typedef Eigen::Matrix<Real, Eigen::Dynamic, 1> RealEigenVector;
typedef Eigen::Matrix<ADReal, Eigen::Dynamic, 1> ADRealEigenVector;
typedef Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim> RealVectorArrayValue;
typedef Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim * Moose::dim> RealTensorArrayValue;
typedef Eigen::Matrix<Real, Eigen::Dynamic, Eigen::Dynamic> RealEigenMatrix;
typedef Eigen::Matrix<ADReal, Eigen::Dynamic, Eigen::Dynamic> ADRealEigenMatrix;
typedef TensorValue<Real> RealTensorValue;
 
namespace TensorTools
{
template <>
struct IncrementRank<Eigen::Matrix<Real, Eigen::Dynamic, 1>>
{
  typedef Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim> type;
};
 
template <>
struct IncrementRank<Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim>>
{
  typedef Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim * Moose::dim> type;
};
 
template <>
struct DecrementRank<Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim>>
{
  typedef Eigen::Matrix<Real, Eigen::Dynamic, 1> type;
};
 
template <>
struct IncrementRank<Eigen::Matrix<ADReal, Eigen::Dynamic, 1>>
{
  typedef Eigen::Matrix<ADReal, Eigen::Dynamic, Moose::dim> type;
};
 
template <>
struct IncrementRank<Eigen::Matrix<ADReal, Eigen::Dynamic, Moose::dim>>
{
  typedef Eigen::Matrix<ADReal, Eigen::Dynamic, Moose::dim * Moose::dim> type;
};
 
template <>
struct DecrementRank<Eigen::Matrix<ADReal, Eigen::Dynamic, Moose::dim>>
{
  typedef Eigen::Matrix<ADReal, Eigen::Dynamic, 1> type;
};
}
}
 
// Common types defined in libMesh
using libMesh::Gradient;
using libMesh::RealGradient;
 
// Bring these common types added to the libMesh namespace in this header
// to global namespace
using libMesh::ADRealEigenMatrix;
using libMesh::ADRealEigenVector;
using libMesh::DenseMatrix;
using libMesh::DenseVector;
using libMesh::RealDIMValue;
using libMesh::RealEigenMatrix;
using libMesh::RealEigenVector;
using libMesh::RealTensorArrayValue;
using libMesh::RealTensorValue;
using libMesh::RealVectorArrayValue;
using libMesh::RealVectorValue;
 
namespace MetaPhysicL
{
template <typename U>
struct ReplaceAlgebraicType<libMesh::RealEigenVector, U>
{
  typedef U type;
};
template <typename U>
struct ReplaceAlgebraicType<libMesh::ADRealEigenVector, U>
{
  typedef U 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 TagTypeID;
typedef unsigned int PerfID;
typedef unsigned int InvalidSolutionID;
using RestartableDataMapName = std::string; // see MooseApp.h
 
typedef libMesh::StoredRange<std::vector<dof_id_type>::iterator, dof_id_type> NodeIdRange;
typedef libMesh::StoredRange<std::vector<const Elem *>::iterator, const Elem *>
    ConstElemPointerRange;
 
namespace Moose
{
 
constexpr std::size_t constMaxQpsPerElem = 1000;
 
// These are used by MooseVariableData and MooseVariableDataFV
enum SolutionState : int
{
  Current = 0,
  Old = 1,
  Older = 2,
  PreviousNL = -1
};
 
enum class SolutionIterationType : unsigned short
{
  Time = 0,
  Nonlinear,
  MultiAppFixedPoint,
  MultiSystemFixedPoint,
  // Special name for determing the total size of
  // iteration types. If adding a new type, it should
  // always be above this entry.
  Count
};
 
// These are used by MooseVariableData and MooseVariableDataFV
enum GeometryType
{
  Volume,
  Face
};
 
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;
};
} // namespace Moose
 
template <typename OutputType>
struct OutputTools
{
  typedef typename libMesh::TensorTools::IncrementRank<OutputType>::type OutputGradient;
  typedef typename libMesh::TensorTools::IncrementRank<OutputGradient>::type OutputSecond;
  typedef typename libMesh::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 libMesh::TensorTools::IncrementRank<OutputShape>::type OutputShapeGradient;
  typedef typename libMesh::TensorTools::IncrementRank<OutputShapeGradient>::type OutputShapeSecond;
  typedef typename libMesh::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>::VariableDivergence VariableDivergence;
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>::VariablePhiDivergence VariablePhiDivergence;
typedef typename OutputTools<Real>::VariableTestValue VariableTestValue;
typedef typename OutputTools<Real>::VariableTestGradient VariableTestGradient;
typedef typename OutputTools<Real>::VariableTestSecond VariableTestSecond;
typedef typename OutputTools<Real>::VariableTestCurl VariableTestCurl;
typedef typename OutputTools<Real>::VariableTestDivergence VariableTestDivergence;
 
// 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>::VariableDivergence VectorVariableDivergence;
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>::VariablePhiDivergence VectorVariablePhiDivergence;
typedef typename OutputTools<RealVectorValue>::VariableTestValue VectorVariableTestValue;
typedef typename OutputTools<RealVectorValue>::VariableTestGradient VectorVariableTestGradient;
typedef typename OutputTools<RealVectorValue>::VariableTestSecond VectorVariableTestSecond;
typedef typename OutputTools<RealVectorValue>::VariableTestCurl VectorVariableTestCurl;
typedef typename OutputTools<RealVectorValue>::VariableTestDivergence VectorVariableTestDivergence;
 
// types for array variable
typedef typename OutputTools<RealEigenVector>::VariableValue ArrayVariableValue;
typedef typename OutputTools<ADRealEigenVector>::VariableValue ADArrayVariableValue;
typedef typename OutputTools<RealEigenVector>::VariableGradient ArrayVariableGradient;
typedef typename OutputTools<ADRealEigenVector>::VariableGradient ADArrayVariableGradient;
typedef typename OutputTools<RealEigenVector>::VariableSecond ArrayVariableSecond;
typedef typename OutputTools<RealEigenVector>::VariableCurl ArrayVariableCurl;
typedef typename OutputTools<RealEigenVector>::VariableDivergence ArrayVariableDivergence;
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>::VariablePhiDivergence ArrayVariablePhiDivergence;
typedef typename OutputTools<RealEigenVector>::VariableTestValue ArrayVariableTestValue;
typedef typename OutputTools<RealEigenVector>::VariableTestGradient ArrayVariableTestGradient;
typedef typename OutputTools<RealEigenVector>::VariableTestSecond ArrayVariableTestSecond;
typedef typename OutputTools<RealEigenVector>::VariableTestCurl ArrayVariableTestCurl;
typedef typename OutputTools<RealEigenVector>::VariableTestDivergence ArrayVariableTestDivergence;
 
/*
typedef typename OutputTools<ADRealEigenVector>::VariableTestValue ADArrayVariableTestValue;
typedef typename OutputTools<ADRealEigenVector>::VariableTestGradient ADArrayVariableTestGradient;
*/
typedef libMesh::VectorValue<ADReal> ADRealVectorValue;
typedef ADRealVectorValue ADRealGradient;
typedef libMesh::VectorValue<ADReal> ADPoint;
typedef libMesh::TensorValue<ADReal> ADRealTensorValue;
typedef libMesh::DenseMatrix<ADReal> ADDenseMatrix;
typedef libMesh::DenseVector<ADReal> ADDenseVector;
typedef MooseArray<ADReal> ADVariableValue;
typedef MooseArray<ADRealVectorValue> ADVariableGradient;
typedef MooseArray<ADRealTensorValue> ADVariableSecond;
typedef MooseArray<ADRealVectorValue> ADVectorVariableValue;
typedef MooseArray<ADRealTensorValue> ADVectorVariableGradient;
typedef MooseArray<libMesh::TypeNTensor<3, ADReal>> ADVectorVariableSecond;
typedef MooseArray<ADRealVectorValue> ADVectorVariableCurl;
 
namespace Moose
{
 
// type conversion from regular to AD
template <typename T>
struct ADType
{
  // unless a specialization exists we assume there is no specific AD type
  typedef T type;
};
 
template <>
struct ADType<Real>
{
  typedef ADReal type;
};
template <>
struct ADType<ChainedReal>
{
  typedef ChainedADReal type;
};
template <>
struct ADType<Point>
{
  typedef ADPoint type;
};
 
template <>
struct ADType<RealVectorValue>
{
  typedef ADRealVectorValue type;
};
template <>
struct ADType<RankTwoTensor>
{
  typedef ADRankTwoTensor type;
};
template <>
struct ADType<RankThreeTensor>
{
  typedef ADRankThreeTensor type;
};
template <>
struct ADType<RankFourTensor>
{
  typedef ADRankFourTensor type;
};
 
template <>
struct ADType<SymmetricRankTwoTensor>
{
  typedef ADSymmetricRankTwoTensor type;
};
template <>
struct ADType<SymmetricRankFourTensor>
{
  typedef ADSymmetricRankFourTensor type;
};
 
template <template <typename T> class W, typename T>
struct ADType<W<T>>
{
  typedef W<typename ADType<T>::type> type;
};
 
template <typename T>
struct ADType<std::vector<T, std::allocator<T>>>
{
  typedef typename ADType<T>::type adT;
  typedef std::vector<adT, std::allocator<adT>> type;
};
 
template <typename T>
struct ADType<std::list<T, std::allocator<T>>>
{
  typedef typename ADType<T>::type adT;
  typedef std::list<adT, std::allocator<adT>> type;
};
 
template <typename T>
struct ADType<std::set<T, std::less<T>, std::allocator<T>>>
{
  typedef typename ADType<T>::type adT;
  typedef std::set<adT, std::less<adT>, std::allocator<adT>> type;
};
 
template <typename T>
struct ADType<DenseVector<T>>
{
  typedef DenseVector<typename ADType<T>::type> type;
};
 
template <typename T>
struct ADType<DenseMatrix<T>>
{
  typedef DenseMatrix<typename ADType<T>::type> type;
};
 
template <>
struct ADType<RealEigenVector>
{
  typedef ADRealEigenVector type;
};
 
template <>
struct ADType<RealEigenMatrix>
{
  typedef ADRealEigenMatrix type;
};
 
template <>
struct ADType<VariableValue>
{
  typedef ADVariableValue type;
};
template <>
struct ADType<VariableGradient>
{
  typedef ADVariableGradient type;
};
template <>
struct ADType<VariableSecond>
{
  typedef ADVariableSecond type;
};
 
template <>
struct ADType<ADReal>
{
  typedef ADReal type;
};
template <>
struct ADType<ChainedADReal>
{
  typedef ChainedADReal type;
};
template <>
struct ADType<ADRankTwoTensor>
{
  typedef ADRankTwoTensor type;
};
template <>
struct ADType<ADRankThreeTensor>
{
  typedef ADRankThreeTensor type;
};
template <>
struct ADType<ADRankFourTensor>
{
  typedef ADRankFourTensor type;
};
 
template <>
struct ADType<ADSymmetricRankTwoTensor>
{
  typedef ADSymmetricRankTwoTensor type;
};
template <>
struct ADType<ADSymmetricRankFourTensor>
{
  typedef ADSymmetricRankFourTensor type;
};
 
template <>
struct ADType<ADVariableValue>
{
  typedef ADVariableValue type;
};
template <>
struct ADType<ADVariableGradient>
{
  typedef ADVariableGradient type;
};
template <>
struct ADType<ADVariableSecond>
{
  typedef ADVariableSecond type;
};
 
template <typename T>
struct IsADType
{
  static constexpr bool value = false;
};
 
template <>
struct IsADType<ADReal>
{
  static constexpr bool value = true;
};
 
template <>
struct IsADType<ADPoint>
{
  static constexpr bool value = true;
};
 
template <template <typename T, typename... Args> class W, typename T, typename... Args>
struct IsADType<W<T, Args...>>
{
  static constexpr bool value = IsADType<T>::value;
};
 
template <typename T, typename... Args>
struct IsADType<MetaPhysicL::DualNumber<T, Args...>>
{
  static constexpr bool value = true;
};
 
template <class... Ts>
constexpr std::false_type always_false{};
 
} // namespace Moose
 
typedef ADRealVectorValue ADRealVectorValue;
typedef ADRealTensorValue ADRealTensorValue;
typedef ADRealGradient ADRealGradient;
 
template <typename T>
using ADTemplateVariableValue =
    typename OutputTools<typename Moose::ADType<T>::type>::VariableValue;
template <typename T>
using ADTemplateVariableGradient =
    typename OutputTools<typename Moose::ADType<T>::type>::VariableGradient;
template <typename T>
using ADTemplateVariableSecond =
    typename OutputTools<typename Moose::ADType<T>::type>::VariableSecond;
template <typename T>
using ADTemplateVariableCurl = typename OutputTools<typename Moose::ADType<T>::type>::VariableCurl;
 
typedef VariableTestValue ADVariableTestValue;
typedef VariableTestGradient ADVariableTestGradient;
typedef VariableTestSecond ADVariableTestSecond;
typedef VectorVariableTestValue ADVectorVariableTestValue;
typedef VectorVariableTestGradient ADVectorVariableTestGradient;
typedef VectorVariableTestSecond ADVectorVariableTestSecond;
 
// We can  use the non-ad version for test values because these don't depend on the mesh
// displacements  (unless the location of the quadrature points depend on the mesh displacements...)
template <typename T>
using ADTemplateVariableTestValue = typename OutputTools<T>::VariableTestValue;
template <typename T>
using ADTemplateVariablePhiValue = typename OutputTools<T>::VariablePhiValue;
 
// We need to use the AD version for test gradients and seconds because these *do* depend on the
// mesh displacements
template <typename T>
using ADTemplateVariableTestGradient =
    typename OutputTools<typename Moose::ADType<T>::type>::VariableTestGradient;
template <typename T>
using ADTemplateVariableTestSecond =
    typename OutputTools<typename Moose::ADType<T>::type>::VariableTestSecond;
template <typename T>
using ADTemplateVariablePhiGradient =
    typename OutputTools<typename Moose::ADType<T>::type>::VariablePhiGradient;
using ADVariablePhiGradient = ADTemplateVariablePhiGradient<Real>;
 
// Templated typed to support is_ad templated classes
namespace Moose
{
template <typename T, bool is_ad>
using GenericType = typename std::conditional<is_ad, typename ADType<T>::type, T>::type;
}
 
template <bool is_ad>
using GenericReal = Moose::GenericType<Real, is_ad>;
template <bool is_ad>
using GenericChainedReal = Moose::GenericType<ChainedReal, is_ad>;
template <bool is_ad>
using GenericRealVectorValue = Moose::GenericType<RealVectorValue, is_ad>;
template <bool is_ad>
using GenericRealTensorValue = Moose::GenericType<RealTensorValue, is_ad>;
template <bool is_ad>
using GenericRankTwoTensor = Moose::GenericType<RankTwoTensor, is_ad>;
template <bool is_ad>
using GenericRankThreeTensor = Moose::GenericType<RankThreeTensor, is_ad>;
template <bool is_ad>
using GenericRankFourTensor = Moose::GenericType<RankFourTensor, is_ad>;
template <bool is_ad>
using GenericVariableValue = Moose::GenericType<VariableValue, is_ad>;
template <bool is_ad>
using GenericVectorVariableValue = Moose::GenericType<VectorVariableValue, is_ad>;
template <bool is_ad>
using GenericVariableGradient = Moose::GenericType<VariableGradient, is_ad>;
template <bool is_ad>
using GenericVariableSecond = Moose::GenericType<VariableSecond, is_ad>;
template <bool is_ad>
using GenericDenseVector = Moose::GenericType<DenseVector<Real>, is_ad>;
template <bool is_ad>
using GenericDenseMatrix = Moose::GenericType<DenseMatrix<Real>, is_ad>;
template <bool is_ad>
using GenericRealEigenVector = Moose::GenericType<RealEigenVector, is_ad>;
template <bool is_ad>
using GenericRealEigenMatrix = Moose::GenericType<RealEigenMatrix, is_ad>;
 
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;
extern const TagID INVALID_TAG_ID;
extern const TagTypeID INVALID_TAG_TYPE_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_SOLVER,
  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_PRIMARY,
  SIDE_SECONDARY
};
 
enum DGResidualType
{
  Element,
  Neighbor
};
 
enum DGJacobianType
{
  ElementElement,
  ElementNeighbor,
  NeighborElement,
  NeighborNeighbor
};
 
enum ConstraintType
{
  Secondary = Element,
  Primary = Neighbor
};
 
enum class ElementType : unsigned int
{
  Element = DGResidualType::Element,
  Neighbor = DGResidualType::Neighbor,
  Lower = DGResidualType::Neighbor + 1
};
 
enum class MortarType : unsigned int
{
  Secondary = static_cast<unsigned int>(Moose::ElementType::Element),
  Primary = static_cast<unsigned int>(Moose::ElementType::Neighbor),
  Lower = static_cast<unsigned int>(Moose::ElementType::Lower)
};
 
enum class ComputeType
{
  Residual,
  Jacobian,
  ResidualAndJacobian
};
 
enum class RESTARTABLE_FILTER : unsigned char
{
  RECOVERABLE
};
 
enum ConstraintJacobianType
{
  SecondarySecondary = ElementElement,
  SecondaryPrimary = ElementNeighbor,
  PrimarySecondary = NeighborElement,
  PrimaryPrimary = NeighborNeighbor,
  LowerLower,
  LowerSecondary,
  LowerPrimary,
  SecondaryLower,
  PrimaryLower
};
 
enum CoordinateSystemType : int
{
  COORD_XYZ = 0,
  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_NEWTON, 
  EST_PJFNK,   
  EST_PJFNKMO, 
  EST_JFNK     
};
 
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,
  LS_SHELL,
  LS_CONTACT,
  LS_PROJECT,
  LS_L2,
  LS_BT,
  LS_CP
};
 
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
};
 
enum VectorTagType
{
  VECTOR_TAG_RESIDUAL = 0,
  VECTOR_TAG_SOLUTION = 1,
  VECTOR_TAG_ANY = 2
};
 
typedef std::function<void(const InputParameters &, InputParameters &)>
    RelationshipManagerInputParameterCallback;
 
std::string stringify(const Moose::RelationshipManagerType & t);
std::string stringify(const Moose::TimeIntegratorType & t);
 
struct DerivativeStringClass
{
};
 
template <typename T>
class Span
{
public:
  using element_type = T;
  using size_type = std::size_t;
  using pointer = T *;
  using reference = T &;
 
  constexpr Span(T * ptr, size_type n) noexcept : _ptr(ptr), _n(n) {}
 
  // observers (enough for std::data / std::size)
  constexpr pointer data() const noexcept { return _ptr; }
  constexpr size_type size() const noexcept { return _n; }
  constexpr bool empty() const noexcept { return _n == 0; }
 
  // optional element/iterator access
  constexpr reference operator[](size_type i) const noexcept { return _ptr[i]; }
  constexpr pointer begin() const noexcept { return _ptr; }
  constexpr pointer end() const noexcept { return _ptr + _n; }
 
private:
  T * _ptr;
  size_type _n;
};
 
template <class C>
auto
makeSpan(C & container, std::size_t offset, std::size_t n)
{
  using PointerType = decltype(std::data(container));
  using ElementType = std::remove_pointer_t<PointerType>;
  return Moose::Span<ElementType>{std::data(container) + offset, n};
}
} // 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);
}
} // namespace libMesh
 
template <>
struct enable_bitmask_operators<Moose::RelationshipManagerType>
{
  static const bool enable = true;
};
 
#define MooseDerivativeStringClass(TheName)                                                        \
  class TheName : public std::string, public Moose::DerivativeStringClass                          \
  {                                                                                                \
  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) {}                                               \
  };                                                                                               \
  namespace nlohmann                                                                               \
  {                                                                                                \
  template <>                                                                                      \
  struct adl_serializer<TheName>                                                                   \
  {                                                                                                \
    static void to_json(json & j, const TheName & v);                                              \
  };                                                                                               \
  }                                                                                                \
  static_assert(true, "")
 
// Instantiate new Types
 
MooseDerivativeStringClass(FileName);
 
MooseDerivativeStringClass(FileNameNoExtension);
 
MooseDerivativeStringClass(RelativeFileName);
 
MooseDerivativeStringClass(DataFileName);
 
MooseDerivativeStringClass(MeshFileName);
 
MooseDerivativeStringClass(MatrixFileName);
 
MooseDerivativeStringClass(OutFileBase);
 
MooseDerivativeStringClass(NonlinearVariableName);
 
MooseDerivativeStringClass(LinearVariableName);
 
MooseDerivativeStringClass(SolverVariableName);
 
MooseDerivativeStringClass(AuxVariableName);
 
MooseDerivativeStringClass(VariableName);
 
MooseDerivativeStringClass(BoundaryName);
 
MooseDerivativeStringClass(SubdomainName);
 
MooseDerivativeStringClass(PostprocessorName);
 
MooseDerivativeStringClass(VectorPostprocessorName);
 
MooseDerivativeStringClass(MeshDivisionName);
 
MooseDerivativeStringClass(FunctionName);
 
MooseDerivativeStringClass(DistributionName);
 
MooseDerivativeStringClass(SamplerName);
 
MooseDerivativeStringClass(UserObjectName);
 
MooseDerivativeStringClass(InterpolationMethodName);
 
MooseDerivativeStringClass(IndicatorName);
 
MooseDerivativeStringClass(MarkerName);
 
MooseDerivativeStringClass(MultiAppName);
 
MooseDerivativeStringClass(OutputName);
 
MooseDerivativeStringClass(MaterialPropertyName);
 
MooseDerivativeStringClass(MooseFunctorName);
 
MooseDerivativeStringClass(MaterialName);
 
MooseDerivativeStringClass(TagName);
 
MooseDerivativeStringClass(MeshGeneratorName);
 
MooseDerivativeStringClass(ExtraElementIDName);
 
MooseDerivativeStringClass(ReporterValueName);
 
MooseDerivativeStringClass(ComponentName);
 
MooseDerivativeStringClass(PhysicsName);
 
MooseDerivativeStringClass(PositionsName);
 
MooseDerivativeStringClass(TimesName);
 
MooseDerivativeStringClass(ExecutorName);
 
MooseDerivativeStringClass(ParsedFunctionExpression);
 
MooseDerivativeStringClass(NonlinearSystemName);
 
MooseDerivativeStringClass(ConvergenceName);
 
MooseDerivativeStringClass(LinearSystemName);
 
MooseDerivativeStringClass(SolverSystemName);
 
MooseDerivativeStringClass(CLIArgString);
 
#ifdef MOOSE_MFEM_ENABLED
MooseDerivativeStringClass(MFEMScalarCoefficientName);
MooseDerivativeStringClass(MFEMVectorCoefficientName);
MooseDerivativeStringClass(MFEMMatrixCoefficientName);
MooseDerivativeStringClass(MFEMFESpaceName);
MooseDerivativeStringClass(MFEMSolverName);
#endif
typedef std::vector<VariableName> CoupledName;
 
namespace Moose
{
extern const TagName SOLUTION_TAG;
extern const TagName OLD_SOLUTION_TAG;
extern const TagName OLDER_SOLUTION_TAG;
extern const TagName PREVIOUS_NL_SOLUTION_TAG;
extern const TagName PREVIOUS_MULTIAPP_FP_SOLUTION_TAG;
extern const TagName PREVIOUS_MULTISYSTEM_FP_SOLUTION_TAG;
extern const TagName SOLUTION_DOT_TAG;
extern const TagName SOLUTION_DOTDOT_TAG;
 
enum class FEBackend
{
  LibMesh
#ifdef MOOSE_MFEM_ENABLED
  ,
  MFEM
#endif
};
 
#ifdef MOOSE_KOKKOS_ENABLED
namespace Kokkos
{
// Passkey for calling special constructors for functor copy
class FunctorCopy
{
  friend class ResidualObject;
  friend class LinearSystemContributionObject;
  friend class KernelBase;
  friend class NodalKernelBase;
  friend class BoundaryCondition;
  friend class LinearFVKernel;
  friend class LinearFVBoundaryCondition;
  friend class IntegratedBCBase;
  friend class NodalBCBase;
  friend class MaterialBase;
  friend class Material;
  friend class AuxKernel;
  friend class FunctionBase;
  friend class UserObject;
  friend class ElementUserObject;
  friend class NodalUserObject;
  friend class SideUserObject;
  friend class GeneralUserObject;
  friend class ElementReducer;
  friend class NodalReducer;
  friend class SideReducer;
  friend class Postprocessor;
  friend class VectorPostprocessor;
  friend class Reporter;
 
  FunctorCopy() {}
  FunctorCopy(const FunctorCopy &) {}
};
}
#endif
}
 
#define usingTensorIndices(...)                                                                    \
  enum                                                                                             \
  {                                                                                                \
    __VA_ARGS__                                                                                    \
  }