https://mooseframework.inl.gov
MooseTypes.h
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://mooseframework.inl.gov
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #pragma once
11 
12 #include "Moose.h"
13 #include "ADReal.h"
14 #include "EigenADReal.h"
15 #include "ChainedReal.h"
16 #include "ChainedADReal.h"
17 #include "ADRankTwoTensorForward.h"
22 
23 // This is not strictly needed here, but it used to be included by ADReal.h
24 // so developers relied heavily on it being already available
25 #include "MooseError.h"
26 
27 #include "libmesh/libmesh.h"
28 #include "libmesh/id_types.h"
29 #include "libmesh/stored_range.h"
30 #include "libmesh/petsc_macro.h"
31 #include "libmesh/boundary_info.h"
32 #include "libmesh/parameters.h"
33 #include "libmesh/dense_vector.h"
34 #include "libmesh/dense_matrix.h"
35 #include "libmesh/int_range.h"
36 
37 // BOOST include
38 #include "boost/bitmask_operators.h"
39 
40 #include "libmesh/ignore_warnings.h"
41 #include "Eigen/Core"
42 #include "libmesh/restore_warnings.h"
43 #include "libmesh/tensor_tools.h"
44 
45 #include "metaphysicl/ct_types.h"
46 
47 #include <string>
48 #include <vector>
49 #include <memory>
50 #include <type_traits>
51 #include <functional>
52 
53 #if !defined(INCLUDE_NLOHMANN_JSON_HPP_) && !defined(MOOSE_NLOHMANN_INCLUDED)
54 #undef INCLUDE_NLOHMANN_JSON_FWD_HPP_
55 #include "nlohmann/json_fwd.h"
56 #define MOOSE_NLOHMANN_INCLUDED
57 #endif
58 
59 // DO NOT USE (Deprecated)
60 #define MooseSharedPointer std::shared_ptr
61 #define MooseSharedNamespace std
62 
70 // The multiple macros that you would need anyway [as per: Crazy Eddie (stack overflow)]
71 #ifdef __clang__
72 #pragma clang diagnostic push
73 #pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
74 #endif
75 
76 #define beginIndex_0() ERROR-- > "beginIndex() requires one or two arguments"
77 #define beginIndex_1(A) decltype(A.size())(0)
78 #define beginIndex_2(A, B) decltype(A.size())(B)
79 #define beginIndex_3(A, B, C) ERROR-- > "beginIndex() requires one or two arguments"
80 #define beginIndex_4(A, B, C, D) ERROR-- > "beginIndex() requires one or two arguments"
81 
82 // The interim macro that simply strips the excess and ends up with the required macro
83 #define beginIndex_X(x, A, B, C, D, FUNC, ...) FUNC
84 
85 // The macro that the programmer uses
86 #define beginIndex(...) \
87  beginIndex_X(, \
88  ##__VA_ARGS__, \
89  beginIndex_4(__VA_ARGS__), \
90  beginIndex_3(__VA_ARGS__), \
91  beginIndex_2(__VA_ARGS__), \
92  beginIndex_1(__VA_ARGS__), \
93  beginIndex_0(__VA_ARGS__))
94 
108 #define MooseIndex(type) decltype(_MooseIndex(type, 0))
109 
110 // SFINAE templates for type MooseIndex type selection
111 template <typename T, typename std::enable_if<std::is_integral<T>::value>::type * = nullptr>
112 typename std::remove_const<T>::type
113 _MooseIndex(T, int)
114 {
115 }
116 
117 template <typename T>
118 decltype(std::declval<T>().size())
119 _MooseIndex(T &&, int)
120 {
121 }
122 
123 template <typename T>
124 decltype("NOTE: MooseIndex only works with integers and objects with size()!")
125 _MooseIndex(T, double) = delete;
126 
127 #ifdef __clang__
128 #pragma clang diagnostic pop
129 #endif
130 
134 template <typename>
135 class MooseArray;
136 template <typename>
137 class MaterialProperty;
138 template <typename>
139 class ADMaterialProperty;
140 class InputParameters;
141 
142 namespace libMesh
143 {
145 typedef Eigen::Matrix<Real, Moose::dim, 1> RealDIMValue;
146 typedef Eigen::Matrix<Real, Eigen::Dynamic, 1> RealEigenVector;
147 typedef Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim> RealVectorArrayValue;
148 typedef Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim * Moose::dim> RealTensorArrayValue;
149 typedef Eigen::Matrix<Real, Eigen::Dynamic, Eigen::Dynamic> RealEigenMatrix;
151 
152 namespace TensorTools
153 {
154 template <>
155 struct IncrementRank<Eigen::Matrix<Real, Eigen::Dynamic, 1>>
156 {
157  typedef Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim> type;
158 };
159 
160 template <>
161 struct IncrementRank<Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim>>
162 {
163  typedef Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim * Moose::dim> type;
164 };
165 
166 template <>
167 struct DecrementRank<Eigen::Matrix<Real, Eigen::Dynamic, Moose::dim>>
168 {
169  typedef Eigen::Matrix<Real, Eigen::Dynamic, 1> type;
170 };
171 }
172 }
173 
174 // Common types defined in libMesh
175 using libMesh::Gradient;
177 
178 // Bring these common types added to the libMesh namespace in this header
179 // to global namespace
189 
190 namespace MetaPhysicL
191 {
192 template <typename U>
193 struct ReplaceAlgebraicType<libMesh::RealEigenVector, U>
194 {
195  typedef U type;
196 };
197 }
198 
203 typedef std::vector<Real> VectorPostprocessorValue;
206 typedef unsigned int InterfaceID;
208 typedef unsigned int MooseObjectID;
209 typedef unsigned int THREAD_ID;
210 typedef unsigned int TagID;
211 typedef unsigned int TagTypeID;
212 typedef unsigned int PerfID;
213 typedef unsigned int InvalidSolutionID;
214 using RestartableDataMapName = std::string; // see MooseApp.h
215 
219 
220 namespace Moose
221 {
222 
230 constexpr std::size_t constMaxQpsPerElem = 1000;
231 
232 // These are used by MooseVariableData and MooseVariableDataFV
233 enum SolutionState : int
234 {
235  Current = 0,
236  Old = 1,
237  Older = 2,
239 };
240 
241 enum class SolutionIterationType : unsigned short
242 {
243  Time = 0,
244  Nonlinear = 1,
245  FixedPoint = 2
246 };
247 
248 // These are used by MooseVariableData and MooseVariableDataFV
250 {
253 };
254 
255 template <typename OutputType>
256 struct ShapeType
257 {
258  typedef OutputType type;
259 };
260 template <>
261 struct ShapeType<Eigen::Matrix<Real, Eigen::Dynamic, 1>>
262 {
263  typedef Real type;
264 };
265 
266 template <typename OutputType>
267 struct DOFType
268 {
269  typedef OutputType type;
270 };
271 template <>
273 {
274  typedef Real type;
275 };
276 } // namespace Moose
277 
278 template <typename OutputType>
280 {
284 
290 
295 
301 
307 
308  // DoF value type for the template class OutputType
311  typedef OutputType OutputValue;
312 };
313 
314 // types for standard variable
330 
331 // types for vector variable
347 
348 // types for array variable
356 typedef std::vector<std::vector<Eigen::Map<RealDIMValue>>> MappedArrayVariablePhiGradient;
365 
382 
383 namespace Moose
384 {
385 
386 // type conversion from regular to AD
387 template <typename T>
388 struct ADType
389 {
390  // unless a specialization exists we assume there is no specific AD type
391  typedef T type;
392 };
393 
394 template <>
395 struct ADType<Real>
396 {
397  typedef ADReal type;
398 };
399 template <>
401 {
403 };
404 template <>
405 struct ADType<Point>
406 {
407  typedef ADPoint type;
408 };
409 
410 template <>
412 {
414 };
415 template <>
417 {
419 };
420 template <>
422 {
424 };
425 template <>
427 {
429 };
430 
431 template <>
433 {
435 };
436 template <>
438 {
440 };
441 
442 template <template <typename T> class W, typename T>
443 struct ADType<W<T>>
444 {
445  typedef W<typename ADType<T>::type> type;
446 };
447 
448 template <typename T>
449 struct ADType<std::vector<T, std::allocator<T>>>
450 {
451  typedef typename ADType<T>::type adT;
452  typedef std::vector<adT, std::allocator<adT>> type;
453 };
454 
455 template <typename T>
456 struct ADType<std::list<T, std::allocator<T>>>
457 {
458  typedef typename ADType<T>::type adT;
459  typedef std::list<adT, std::allocator<adT>> type;
460 };
461 
462 template <typename T>
463 struct ADType<std::set<T, std::less<T>, std::allocator<T>>>
464 {
465  typedef typename ADType<T>::type adT;
466  typedef std::set<adT, std::less<adT>, std::allocator<adT>> type;
467 };
468 
469 template <typename T>
470 struct ADType<DenseVector<T>>
471 {
473 };
474 
475 template <typename T>
476 struct ADType<DenseMatrix<T>>
477 {
479 };
480 
481 template <>
483 {
485 };
486 template <>
488 {
490 };
491 template <>
493 {
495 };
496 template <>
498 {
500 };
501 
502 template <>
503 struct ADType<ADReal>
504 {
505  typedef ADReal type;
506 };
507 template <>
509 {
511 };
512 template <>
514 {
516 };
517 template <>
519 {
521 };
522 template <>
524 {
526 };
527 
528 template <>
530 {
532 };
533 template <>
535 {
537 };
538 
539 template <>
541 {
543 };
544 template <>
546 {
548 };
549 template <>
551 {
553 };
554 
555 template <typename T>
556 struct IsADType
557 {
558  static constexpr bool value = false;
559 };
560 
561 template <>
563 {
564  static constexpr bool value = true;
565 };
566 
567 template <>
569 {
570  static constexpr bool value = true;
571 };
572 
573 template <template <typename T, typename... Args> class W, typename T, typename... Args>
574 struct IsADType<W<T, Args...>>
575 {
576  static constexpr bool value = IsADType<T>::value;
577 };
578 
579 template <typename T, typename... Args>
580 struct IsADType<MetaPhysicL::DualNumber<T, Args...>>
581 {
582  static constexpr bool value = true;
583 };
584 
590 template <class... Ts>
591 constexpr std::false_type always_false{};
592 
593 } // namespace Moose
594 
601 
602 template <typename T>
605 template <typename T>
608 template <typename T>
611 template <typename T>
613 
620 
621 // We can use the non-ad version for test values because these don't depend on the mesh
622 // displacements (unless the location of the quadrature points depend on the mesh displacements...)
623 template <typename T>
625 template <typename T>
627 
628 // We need to use the AD version for test gradients and seconds because these *do* depend on the
629 // mesh displacements
630 template <typename T>
633 template <typename T>
636 template <typename T>
640 
641 // Templated typed to support is_ad templated classes
642 namespace Moose
643 {
644 template <typename T, bool is_ad>
645 using GenericType = typename std::conditional<is_ad, typename ADType<T>::type, T>::type;
646 }
647 
648 template <bool is_ad>
650 template <bool is_ad>
652 template <bool is_ad>
654 template <bool is_ad>
656 template <bool is_ad>
658 template <bool is_ad>
660 template <bool is_ad>
662 template <bool is_ad>
664 template <bool is_ad>
666 template <bool is_ad>
668 template <bool is_ad>
670 template <bool is_ad>
672 template <bool is_ad>
674 
675 namespace Moose
676 {
678 extern const SubdomainID ANY_BLOCK_ID;
679 extern const SubdomainID INVALID_BLOCK_ID;
680 extern const BoundaryID ANY_BOUNDARY_ID;
681 extern const BoundaryID INVALID_BOUNDARY_ID;
682 extern const TagID INVALID_TAG_ID;
683 extern const TagTypeID INVALID_TAG_TYPE_ID;
684 const std::set<SubdomainID> EMPTY_BLOCK_IDS = {};
685 const std::set<BoundaryID> EMPTY_BOUNDARY_IDS = {};
686 
693 {
699 };
700 
705 {
706  PRE_IC = 0,
707  PRE_AUX = 1,
708  POST_AUX = 2,
709  ALL = 3
710 };
711 
716 {
720 };
721 
723 {
729 };
730 
732 {
736 };
737 
739 {
742 };
743 
745 {
748 };
749 
751 {
756 };
757 
759 {
762 };
763 
764 enum class ElementType : unsigned int
765 {
769 };
770 
771 enum class MortarType : unsigned int
772 {
773  Secondary = static_cast<unsigned int>(Moose::ElementType::Element),
774  Primary = static_cast<unsigned int>(Moose::ElementType::Neighbor),
775  Lower = static_cast<unsigned int>(Moose::ElementType::Lower)
776 };
777 
781 enum class ComputeType
782 {
783  Residual,
784  Jacobian,
786 };
787 
792 enum class RESTARTABLE_FILTER : unsigned char
793 {
795 };
796 
798 {
808 };
809 
811 {
815 };
816 
821 {
826 };
827 
832 {
838 };
839 
844 {
850 };
851 
856 {
866 };
867 
872 {
880 };
881 
886 {
898 };
899 
904 {
913 };
914 
919 {
922 };
927 {
938 };
939 
944 {
948 };
949 
954 {
959 };
960 
964 enum class RelationshipManagerType : unsigned char
965 {
966  DEFAULT = 0,
967  GEOMETRIC = 1 << 0,
968  ALGEBRAIC = 1 << 1,
969  COUPLING = 1 << 2
970 };
971 
973 {
977 };
978 
980 {
984 };
985 
989 typedef std::function<void(const InputParameters &, InputParameters &)>
991 
992 std::string stringify(const Moose::RelationshipManagerType & t);
993 std::string stringify(const Moose::TimeIntegratorType & t);
994 
999 {
1000 };
1001 
1002 } // namespace Moose
1003 
1004 namespace libMesh
1005 {
1006 template <>
1007 inline void
1008 print_helper(std::ostream & os, const Moose::RelationshipManagerType * param)
1009 {
1010  // Specialization so that we don't print out unprintable characters
1011  os << Moose::stringify(*param);
1012 }
1013 } // namespace libMesh
1014 
1015 template <>
1016 struct enable_bitmask_operators<Moose::RelationshipManagerType>
1017 {
1018  static const bool enable = true;
1019 };
1020 
1029 #define MooseDerivativeStringClass(TheName) \
1030  class TheName : public std::string, public Moose::DerivativeStringClass \
1031  { \
1032  public: \
1033  TheName() : std::string() {} \
1034  TheName(const std::string & str) : std::string(str) {} \
1035  TheName(const std::string & str, size_t pos, size_t n = npos) : std::string(str, pos, n) {} \
1036  TheName(const char * s, size_t n) : std::string(s, n) {} \
1037  TheName(const char * s) : std::string(s) {} \
1038  TheName(size_t n, char c) : std::string(n, c) {} \
1039  }; \
1040  namespace nlohmann \
1041  { \
1042  template <> \
1043  struct adl_serializer<TheName> \
1044  { \
1045  static void to_json(json & j, const TheName & v); \
1046  }; \
1047  } \
1048  static_assert(true, "")
1049 
1050 // Instantiate new Types
1051 
1055 MooseDerivativeStringClass(FileName);
1056 
1058 MooseDerivativeStringClass(FileNameNoExtension);
1059 
1062 MooseDerivativeStringClass(RelativeFileName);
1063 
1066 MooseDerivativeStringClass(DataFileName);
1067 
1069 MooseDerivativeStringClass(MeshFileName);
1070 
1072 MooseDerivativeStringClass(MatrixFileName);
1073 
1075 MooseDerivativeStringClass(OutFileBase);
1076 
1078 MooseDerivativeStringClass(NonlinearVariableName);
1079 
1081 MooseDerivativeStringClass(LinearVariableName);
1082 
1084 MooseDerivativeStringClass(SolverVariableName);
1085 
1087 MooseDerivativeStringClass(AuxVariableName);
1088 
1090 MooseDerivativeStringClass(VariableName);
1091 
1093 MooseDerivativeStringClass(BoundaryName);
1094 
1096 MooseDerivativeStringClass(SubdomainName);
1097 
1099 MooseDerivativeStringClass(PostprocessorName);
1100 
1102 MooseDerivativeStringClass(VectorPostprocessorName);
1103 
1105 MooseDerivativeStringClass(MeshDivisionName);
1106 
1108 MooseDerivativeStringClass(FunctionName);
1109 
1111 MooseDerivativeStringClass(DistributionName);
1112 
1114 MooseDerivativeStringClass(SamplerName);
1115 
1117 MooseDerivativeStringClass(UserObjectName);
1118 
1120 MooseDerivativeStringClass(IndicatorName);
1121 
1123 MooseDerivativeStringClass(MarkerName);
1124 
1126 MooseDerivativeStringClass(MultiAppName);
1127 
1129 MooseDerivativeStringClass(OutputName);
1130 
1132 MooseDerivativeStringClass(MaterialPropertyName);
1133 
1135 MooseDerivativeStringClass(MooseFunctorName);
1136 
1138 MooseDerivativeStringClass(MaterialName);
1139 
1142 
1144 MooseDerivativeStringClass(MeshGeneratorName);
1145 
1147 MooseDerivativeStringClass(ExtraElementIDName);
1148 
1150 MooseDerivativeStringClass(ReporterValueName);
1151 
1153 MooseDerivativeStringClass(ComponentName);
1154 
1156 MooseDerivativeStringClass(PhysicsName);
1157 
1159 MooseDerivativeStringClass(PositionsName);
1160 
1162 MooseDerivativeStringClass(TimesName);
1163 
1165 MooseDerivativeStringClass(ExecutorName);
1166 
1168 MooseDerivativeStringClass(ParsedFunctionExpression);
1169 
1171 MooseDerivativeStringClass(NonlinearSystemName);
1172 
1174 MooseDerivativeStringClass(ConvergenceName);
1175 
1177 MooseDerivativeStringClass(LinearSystemName);
1178 
1180 MooseDerivativeStringClass(SolverSystemName);
1181 
1183 MooseDerivativeStringClass(CLIArgString);
1184 
1185 #ifdef MOOSE_MFEM_ENABLED
1186 
1189 MooseDerivativeStringClass(MFEMScalarCoefficientName);
1191 MooseDerivativeStringClass(MFEMVectorCoefficientName);
1192 MooseDerivativeStringClass(MFEMMatrixCoefficientName);
1194 #endif
1195 
1198 typedef std::vector<VariableName> CoupledName;
1199 
1200 namespace Moose
1201 {
1202 extern const TagName SOLUTION_TAG;
1203 extern const TagName OLD_SOLUTION_TAG;
1204 extern const TagName OLDER_SOLUTION_TAG;
1205 extern const TagName PREVIOUS_NL_SOLUTION_TAG;
1206 extern const TagName PREVIOUS_FP_SOLUTION_TAG;
1207 extern const TagName SOLUTION_DOT_TAG;
1208 extern const TagName SOLUTION_DOTDOT_TAG;
1209 
1210 enum class FEBackend
1211 {
1212  LibMesh
1213 #ifdef MOOSE_MFEM_ENABLED
1214  ,
1215  MFEM
1216 #endif
1217 };
1218 
1219 #ifdef MOOSE_KOKKOS_ENABLED
1220 namespace Kokkos
1221 {
1222 // Passkey for calling special constructors for functor copy
1224 {
1225  friend class ResidualObject;
1226  friend class KernelBase;
1227  friend class NodalKernelBase;
1228  friend class BoundaryCondition;
1229  friend class IntegratedBCBase;
1230  friend class NodalBCBase;
1231  friend class MaterialBase;
1232  friend class Material;
1233 
1234  FunctorCopy() = default;
1235  FunctorCopy(const FunctorCopy &) = delete;
1236  FunctorCopy(FunctorCopy &&) = delete;
1237 };
1238 }
1239 #endif
1240 }
1241 
1243 #define usingTensorIndices(...) \
1244  enum \
1245  { \
1246  __VA_ARGS__ \
1247  }
ConstraintFormulationType
Type of constraint formulation.
Definition: MooseTypes.h:918
typename OutputTools< typename Moose::ADType< T >::type >::VariableSecond ADTemplateVariableSecond
Definition: MooseTypes.h:610
OutputTools< Real >::VariableGradient VariableGradient
Definition: MooseTypes.h:316
VarFieldType
Definition: MooseTypes.h:722
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Generalized Non-Hermitian.
Definition: MooseTypes.h:877
OutputTools< RealVectorValue >::VariableDivergence VectorVariableDivergence
Definition: MooseTypes.h:336
RealVectorValue RealGradient
Moose::GenericType< Real, is_ad > GenericReal
Definition: MooseTypes.h:649
typename OutputTools< typename Moose::ADType< T >::type >::VariableCurl ADTemplateVariableCurl
Definition: MooseTypes.h:612
Moose::GenericType< VectorVariableValue, is_ad > GenericVectorVariableValue
Definition: MooseTypes.h:665
unsigned int TagTypeID
Definition: MooseTypes.h:211
Generalized Hermitian indefinite.
Definition: MooseTypes.h:876
OutputTools< RealVectorValue >::VariableSecond VectorVariableSecond
Definition: MooseTypes.h:334
Newton-based eigensolver with an assembled Jacobian matrix (fully coupled by default) ...
Definition: MooseTypes.h:862
Full Newton Solve.
Definition: MooseTypes.h:847
OutputTools< RealEigenVector >::VariableDivergence ArrayVariableDivergence
Definition: MooseTypes.h:353
typename OutputTools< typename Moose::ADType< T >::type >::VariablePhiGradient ADTemplateVariablePhiGradient
Definition: MooseTypes.h:638
ConstraintType
Definition: MooseTypes.h:758
smallest magnitude
Definition: MooseTypes.h:888
libMesh::DenseMatrix< ADReal > ADDenseMatrix
Definition: MooseTypes.h:373
const TagTypeID INVALID_TAG_TYPE_ID
Definition: MooseTypes.C:24
libMesh::TensorTools::IncrementRank< OutputGradient >::type OutputSecond
Definition: MooseTypes.h:282
EigenSolveType
Type of the eigen solve.
Definition: MooseTypes.h:855
RelationshipManagerType
Main types of Relationship Managers.
Definition: MooseTypes.h:964
void print_helper(std::ostream &os, const P *param)
OutputTools< Real >::VariableTestDivergence VariableTestDivergence
Definition: MooseTypes.h:329
std::set< adT, std::less< adT >, std::allocator< adT > > type
Definition: MooseTypes.h:466
unsigned int TagID
Definition: MooseTypes.h:210
unsigned int InvalidSolutionID
Definition: MooseTypes.h:213
MooseArray< std::vector< OutputShapeGradient > > VariablePhiGradient
Definition: MooseTypes.h:297
VectorValue< Real > RealVectorValue
Definition: SubProblem.h:33
subdomain_id_type SubdomainID
Definition: MooseTypes.h:207
typename OutputTools< typename Moose::ADType< T >::type >::VariableTestSecond ADTemplateVariableTestSecond
Definition: MooseTypes.h:635
OutputTools< RealVectorValue >::VariableTestCurl VectorVariableTestCurl
Definition: MooseTypes.h:345
const BoundaryID INVALID_BOUNDARY_ID
Definition: MooseTypes.C:22
const TagName OLDER_SOLUTION_TAG
Definition: MooseTypes.C:27
DenseVector< typename ADType< T >::type > type
Definition: MooseTypes.h:472
MooseArray< std::vector< OutputShapeDivergence > > VariablePhiDivergence
Definition: MooseTypes.h:300
MooseArray< std::vector< OutputShapeDivergence > > VariableTestDivergence
Definition: MooseTypes.h:306
OutputType type
Definition: MooseTypes.h:269
OutputType type
Definition: MooseTypes.h:258
OutputTools< RealEigenVector >::VariablePhiValue ArrayVariablePhiValue
Definition: MooseTypes.h:354
constexpr std::size_t constMaxQpsPerElem
This is used for places where we initialize some qp-sized data structures that would end up being siz...
Definition: MooseTypes.h:230
DualNumber< Real, Real > ChainedReal
Definition: ChainedReal.h:30
typename OutputTools< T >::VariableTestValue ADTemplateVariableTestValue
Definition: MooseTypes.h:624
The same as PJFNK except that matrix-vector multiplication is employed to replace residual evaluation...
Definition: MooseTypes.h:864
MortarType
Definition: MooseTypes.h:771
MooseArray< std::vector< OutputShape > > VariableTestValue
Definition: MooseTypes.h:302
VariableTestGradient ADVariableTestGradient
Definition: MooseTypes.h:615
OutputTools< RealVectorValue >::VariableValue VectorVariableValue
Definition: MooseTypes.h:332
libMesh::DenseVector< ADReal > ADDenseVector
Definition: MooseTypes.h:374
MaterialDataType
MaterialData types.
Definition: MooseTypes.h:692
MooseArray< std::vector< OutputShapeGradient > > VariableTestGradient
Definition: MooseTypes.h:303
OutputType OutputValue
Definition: MooseTypes.h:311
Definition: JsonIO.h:48
constexpr std::false_type always_false
This is a helper variable template for cases when we want to use a default compile-time error with co...
Definition: MooseTypes.h:591
MooseArray< ADRealVectorValue > ADVariableGradient
Definition: MooseTypes.h:376
typename OutputTools< T >::VariablePhiValue ADTemplateVariablePhiValue
Definition: MooseTypes.h:626
DenseMatrix< typename ADType< T >::type > type
Definition: MooseTypes.h:478
OutputTools< RealVectorValue >::VariableTestValue VectorVariableTestValue
Definition: MooseTypes.h:342
libMesh::StoredRange< std::vector< dof_id_type >::iterator, dof_id_type > NodeIdRange
Definition: MooseTypes.h:216
MooseArray< ADRealVectorValue > ADVectorVariableCurl
Definition: MooseTypes.h:381
typename OutputTools< typename Moose::ADType< T >::type >::VariableValue ADTemplateVariableValue
Definition: MooseTypes.h:604
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
OutputTools< RealEigenVector >::VariableCurl ArrayVariableCurl
Definition: MooseTypes.h:352
The base class for Kokkos residual objects.
ADTemplateVariablePhiGradient< Real > ADVariablePhiGradient
Definition: MooseTypes.h:639
The base class for Kokkos integrated boundary conditions.
Solving a linear problem.
Definition: MooseTypes.h:849
OutputTools< RealEigenVector >::VariableSecond ArrayVariableSecond
Definition: MooseTypes.h:351
OutputTools< Real >::VariablePhiValue VariablePhiValue
Definition: MooseTypes.h:320
MooseArray< OutputData > DoFValue
Definition: MooseTypes.h:310
OutputTools< RealVectorValue >::VariableCurl VectorVariableCurl
Definition: MooseTypes.h:335
use whatever SLPEC has by default
Definition: MooseTypes.h:879
OutputTools< RealVectorValue >::VariablePhiGradient VectorVariablePhiGradient
Definition: MooseTypes.h:338
MooseDerivativeStringClass(FileName)
This type is for expected (i.e.
target magnitude
Definition: MooseTypes.h:893
OutputTools< RealEigenVector >::VariablePhiSecond ArrayVariablePhiSecond
Definition: MooseTypes.h:357
We need to instantiate the following CompareTypes to tell the compiler that ADReal is a subtype of Ch...
Moose::GenericType< RealTensorValue, is_ad > GenericRealTensorValue
Definition: MooseTypes.h:655
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
ElementType
Definition: MooseTypes.h:764
std::basic_ostream< charT, traits > * os
Definition: InfixIterator.h:33
DGResidualType
Definition: MooseTypes.h:744
libMesh::TensorValue< ADReal > ADRealTensorValue
Definition: MooseTypes.h:372
DualNumber< Real, DNDerivativeType, true > ADReal
Definition: ADRealForward.h:46
Moose::GenericType< DenseVector< Real >, is_ad > GenericDenseVector
Definition: MooseTypes.h:671
const TagName PREVIOUS_FP_SOLUTION_TAG
Definition: MooseTypes.C:29
Generalized Non-Hermitian with positive (semi-)definite B.
Definition: MooseTypes.h:878
MooseArray< OutputType > VariableValue
Definition: MooseTypes.h:285
MooseArray< libMesh::TypeNTensor< 3, ADReal > > ADVectorVariableSecond
Definition: MooseTypes.h:380
MffdType
Type of the matrix-free finite-differencing parameter.
Definition: MooseTypes.h:943
Moose::GenericType< RankFourTensor, is_ad > GenericRankFourTensor
Definition: MooseTypes.h:661
VectorVariableTestSecond ADVectorVariableTestSecond
Definition: MooseTypes.h:619
OutputTools< Real >::VariablePhiSecond VariablePhiSecond
Definition: MooseTypes.h:322
Power / Inverse / RQI.
Definition: MooseTypes.h:857
typename std::conditional< is_ad, typename ADType< T >::type, T >::type GenericType
Definition: MooseTypes.h:645
Krylov-Schur.
Definition: MooseTypes.h:859
unsigned int PerfID
Definition: MooseTypes.h:212
AuxGroup
Flag for AuxKernel related execution type.
Definition: MooseTypes.h:704
RankThreeTensor is designed to handle any N-dimensional third order tensor, r.
Eigen::Matrix< Real, Eigen::Dynamic, Moose::dim *Moose::dim > type
Definition: MooseTypes.h:163
MooseArray< ADReal > ADVariableValue
Definition: MooseTypes.h:375
VariableTestSecond ADVariableTestSecond
Definition: MooseTypes.h:616
MooseKSPNormType
Norm type for converge test.
Definition: MooseTypes.h:831
const SubdomainID INVALID_BLOCK_ID
Definition: MooseTypes.C:20
The base class for Kokkos nodal kernels.
libMesh::TensorTools::IncrementRank< OutputShapeGradient >::type OutputShapeSecond
Definition: MooseTypes.h:293
MooseArray< std::vector< OutputShape > > VariablePhiValue
Definition: MooseTypes.h:296
OutputTools< RealVectorValue >::VariablePhiDivergence VectorVariablePhiDivergence
Definition: MooseTypes.h:341
TensorValue< Real > RealTensorValue
uint8_t processor_id_type
The base class for Kokkos boundary conditions.
libMesh::TensorTools::IncrementRank< OutputType >::type OutputGradient
Definition: MooseTypes.h:281
libMesh::TensorTools::DecrementRank< OutputType >::type OutputDivergence
Definition: MooseTypes.h:283
std::remove_const< T >::type _MooseIndex(T, int)
Definition: MooseTypes.h:113
Use whatever we have in PETSc.
Definition: MooseTypes.h:825
Preconditioned Jacobian-free Newton Krylov.
Definition: MooseTypes.h:863
WhichEigenPairs
Which eigen pairs.
Definition: MooseTypes.h:885
int8_t boundary_id_type
OutputTools< RealEigenVector >::VariableTestDivergence ArrayVariableTestDivergence
Definition: MooseTypes.h:364
OutputTools< RealEigenVector >::VariableValue ArrayVariableValue
Definition: MooseTypes.h:349
OutputTools< RealVectorValue >::VariableTestDivergence VectorVariableTestDivergence
Definition: MooseTypes.h:346
MooseArray< ADRealTensorValue > ADVectorVariableGradient
Definition: MooseTypes.h:379
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
OutputTools< Real >::VariableCurl VariableCurl
Definition: MooseTypes.h:318
LineSearchType
Type of the line search.
Definition: MooseTypes.h:926
RESTARTABLE_FILTER
The filter type applied to a particular piece of "restartable" data.
Definition: MooseTypes.h:792
Moose::GenericType< VariableValue, is_ad > GenericVariableValue
Definition: MooseTypes.h:663
const TagName OLD_SOLUTION_TAG
Definition: MooseTypes.C:26
Use whatever we have in PETSc.
Definition: MooseTypes.h:837
Moose::GenericType< VariableGradient, is_ad > GenericVariableGradient
Definition: MooseTypes.h:667
std::function< void(const InputParameters &, InputParameters &)> RelationshipManagerInputParameterCallback
The type for the callback to set RelationshipManager parameters.
Definition: MooseTypes.h:990
libMesh::VectorValue< ADReal > ADPoint
Definition: MooseTypes.h:371
const TagName SOLUTION_DOTDOT_TAG
Definition: MooseTypes.C:31
OutputTools< RealVectorValue >::VariablePhiSecond VectorVariablePhiSecond
Definition: MooseTypes.h:339
OutputTools< Real >::VariableTestValue VariableTestValue
Definition: MooseTypes.h:325
boundary_id_type BoundaryID
VarKindType
Framework-wide stuff.
Definition: MooseTypes.h:715
Jacobian-Free Newton Krylov.
Definition: MooseTypes.h:846
std::vector< std::vector< Eigen::Map< RealDIMValue > > > MappedArrayVariablePhiGradient
Definition: MooseTypes.h:356
Real PostprocessorValue
various MOOSE typedefs
Definition: MooseTypes.h:202
typename OutputTools< typename Moose::ADType< T >::type >::VariableTestGradient ADTemplateVariableTestGradient
Definition: MooseTypes.h:632
ADSymmetricRankFourTensor type
Definition: MooseTypes.h:439
OutputTools< Real >::VariableDivergence VariableDivergence
Definition: MooseTypes.h:319
NumberVectorValue Gradient
MooseArray< std::vector< OutputShape > > VariableTestCurl
Definition: MooseTypes.h:305
MooseArray< OutputSecond > VariableSecond
Definition: MooseTypes.h:287
unsigned int InterfaceID
Definition: MooseTypes.h:206
Moose::ShapeType< OutputType >::type OutputShape
Definition: MooseTypes.h:291
typename OutputTools< typename Moose::ADType< T >::type >::VariableGradient ADTemplateVariableGradient
Definition: MooseTypes.h:607
target imaginary
Definition: MooseTypes.h:895
The base class for Kokkos kernels.
OutputTools< Real >::VariablePhiCurl VariablePhiCurl
Definition: MooseTypes.h:323
MooseArray< OutputGradient > VariableGradient
Definition: MooseTypes.h:286
Use finite differences to compute Jacobian.
Definition: MooseTypes.h:848
MooseArray< OutputType > VariableCurl
Definition: MooseTypes.h:288
Moose::GenericType< RealVectorValue, is_ad > GenericRealVectorValue
Definition: MooseTypes.h:653
Moose::GenericType< ChainedReal, is_ad > GenericChainedReal
Definition: MooseTypes.h:651
Eigen::Matrix< Real, Eigen::Dynamic, Eigen::Dynamic > RealEigenMatrix
Definition: MooseTypes.h:149
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
Nonlinear inverse power.
Definition: MooseTypes.h:861
The base class for Kokkos nodal boundary conditions.
OutputTools< Real >::VariablePhiDivergence VariablePhiDivergence
Definition: MooseTypes.h:324
VectorTagType
Definition: MooseTypes.h:979
ComputeType
The type of nonlinear computation being performed.
Definition: MooseTypes.h:781
Jacobi-Davidson.
Definition: MooseTypes.h:860
const processor_id_type INVALID_PROCESSOR_ID
Definition: MooseTypes.C:18
Eigen::Matrix< Real, Eigen::Dynamic, Moose::dim > RealVectorArrayValue
Definition: MooseTypes.h:147
OutputTools< Real >::VariableValue VariableValue
Definition: MooseTypes.h:315
DGJacobianType
Definition: MooseTypes.h:750
ConstraintSideType
Definition: MooseTypes.h:738
std::vector< Real > VectorPostprocessorValue
Definition: MooseTypes.h:203
Real ScatterVectorPostprocessorValue
Definition: MooseTypes.h:204
OutputTools< Real >::VariablePhiGradient VariablePhiGradient
Definition: MooseTypes.h:321
std::list< adT, std::allocator< adT > > type
Definition: MooseTypes.h:459
MooseArray< std::vector< OutputShapeSecond > > VariablePhiSecond
Definition: MooseTypes.h:298
Struct that all MOOSE derivative strings derive from.
Definition: MooseTypes.h:998
MooseArray< std::vector< OutputShape > > VariablePhiCurl
Definition: MooseTypes.h:299
const SubdomainID ANY_BLOCK_ID
Definition: MooseTypes.C:19
forward declarations
The base class for a user to derive their own Kokkos materials.
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const std::set< SubdomainID > EMPTY_BLOCK_IDS
Definition: MooseTypes.h:684
OutputTools< Real >::VariableTestSecond VariableTestSecond
Definition: MooseTypes.h:327
OutputTools< RealVectorValue >::VariableTestGradient VectorVariableTestGradient
Definition: MooseTypes.h:343
OutputTools< RealVectorValue >::VariablePhiValue VectorVariablePhiValue
Definition: MooseTypes.h:337
GeometryType
Definition: MooseTypes.h:249
OutputTools< RealEigenVector >::VariableTestSecond ArrayVariableTestSecond
Definition: MooseTypes.h:362
CoordinateSystemType
Definition: MooseTypes.h:810
smallest imaginary
Definition: MooseTypes.h:892
std::string RestartableDataMapName
Definition: MooseTypes.h:214
VectorVariableTestValue ADVectorVariableTestValue
Definition: MooseTypes.h:617
const std::set< BoundaryID > EMPTY_BOUNDARY_IDS
Definition: MooseTypes.h:685
const TagID INVALID_TAG_ID
Definition: MooseTypes.C:23
std::vector< VariableName > CoupledName
additional MOOSE typedefs
Definition: MooseTypes.h:1198
RMSystemType
Definition: MooseTypes.h:972
OutputTools< RealVectorValue >::VariableTestSecond VectorVariableTestSecond
Definition: MooseTypes.h:344
SolutionState
Definition: MooseTypes.h:233
Jacobian-free Newton Krylov.
Definition: MooseTypes.h:865
means not set
Definition: MooseTypes.h:945
PatchUpdateType
Type of patch update strategy for modeling node-face constraints or contact.
Definition: MooseTypes.h:953
MooseArray< std::vector< OutputShapeSecond > > VariableTestSecond
Definition: MooseTypes.h:304
ConstraintJacobianType
Definition: MooseTypes.h:797
OutputTools< RealEigenVector >::VariablePhiDivergence ArrayVariablePhiDivergence
Definition: MooseTypes.h:359
SymmetricRankFourTensorTempl is designed to handle an N-dimensional fourth order tensor with minor sy...
largest imaginary
Definition: MooseTypes.h:891
libMesh::TensorTools::DecrementRank< OutputShape >::type OutputShapeDivergence
Definition: MooseTypes.h:294
OutputTools< RealEigenVector >::VariablePhiCurl ArrayVariablePhiCurl
Definition: MooseTypes.h:358
Non-Hermitian.
Definition: MooseTypes.h:874
CouplingType
Definition: MooseTypes.h:731
OutputTools< RealEigenVector >::VariablePhiGradient ArrayVariablePhiGradient
Definition: MooseTypes.h:355
TimeIntegratorType
Time integrators.
Definition: MooseTypes.h:903
MooseArray< ADRealTensorValue > ADVariableSecond
Definition: MooseTypes.h:377
PCSideType
Preconditioning side.
Definition: MooseTypes.h:820
ADRealVectorValue ADRealGradient
Definition: MooseTypes.h:370
VectorVariableTestGradient ADVectorVariableTestGradient
Definition: MooseTypes.h:618
Moose::DOFType< OutputType >::type OutputData
Definition: MooseTypes.h:309
VariableTestValue ADVariableTestValue
Definition: MooseTypes.h:614
all eigenvalues
Definition: MooseTypes.h:896
Moose::GenericType< RankThreeTensor, is_ad > GenericRankThreeTensor
Definition: MooseTypes.h:659
Moose::GenericType< VariableSecond, is_ad > GenericVariableSecond
Definition: MooseTypes.h:669
const TagName SOLUTION_TAG
Definition: MooseTypes.C:25
OutputTools< Real >::VariableSecond VariableSecond
Definition: MooseTypes.h:317
Eigen::Matrix< Real, Eigen::Dynamic, 1 > RealEigenVector
Definition: MooseTypes.h:146
Preconditioned Jacobian-Free Newton Krylov.
Definition: MooseTypes.h:845
Eigen::Matrix< Real, Moose::dim, 1 > RealDIMValue
Definition: MooseTypes.h:145
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
OutputTools< RealVectorValue >::VariablePhiCurl VectorVariablePhiCurl
Definition: MooseTypes.h:340
MooseArray< OutputDivergence > VariableDivergence
Definition: MooseTypes.h:289
use whatever we have in SLEPC
Definition: MooseTypes.h:897
OutputTools< RealVectorValue >::VariableGradient VectorVariableGradient
Definition: MooseTypes.h:333
means not set
Definition: MooseTypes.h:928
libMesh::StoredRange< std::vector< const Elem * >::iterator, const Elem * > ConstElemPointerRange
Definition: MooseTypes.h:218
largest magnitude
Definition: MooseTypes.h:887
Eigen::Matrix< Real, Eigen::Dynamic, Moose::dim *Moose::dim > RealTensorArrayValue
Definition: MooseTypes.h:148
std::vector< adT, std::allocator< adT > > type
Definition: MooseTypes.h:452
OutputTools< Real >::VariableTestCurl VariableTestCurl
Definition: MooseTypes.h:328
OutputTools< RealEigenVector >::VariableTestValue ArrayVariableTestValue
Definition: MooseTypes.h:360
SolveType
Type of the solve.
Definition: MooseTypes.h:843
OutputTools< Real >::VariableTestGradient VariableTestGradient
Definition: MooseTypes.h:326
W< typename ADType< T >::type > type
Definition: MooseTypes.h:445
OutputTools< RealEigenVector >::VariableGradient ArrayVariableGradient
Definition: MooseTypes.h:350
const TagName PREVIOUS_NL_SOLUTION_TAG
Definition: MooseTypes.C:28
static constexpr bool value
Definition: MooseTypes.h:558
unsigned int MooseObjectID
Definition: MooseTypes.h:208
libMesh::VectorValue< ADReal > ADRealVectorValue
AD typedefs.
Definition: MooseTypes.h:369
MooseArray< ADRealVectorValue > ADVectorVariableValue
Definition: MooseTypes.h:378
The base class for Kokkos materials.
OutputTools< RealEigenVector >::VariableTestGradient ArrayVariableTestGradient
Definition: MooseTypes.h:361
libMesh::TensorTools::IncrementRank< OutputShape >::type OutputShapeGradient
Definition: MooseTypes.h:292
EigenProblemType
Type of the eigen problem.
Definition: MooseTypes.h:871
ADSymmetricRankTwoTensor type
Definition: MooseTypes.h:434
Moose::GenericType< DenseMatrix< Real >, is_ad > GenericDenseMatrix
Definition: MooseTypes.h:673
void ErrorVector unsigned int
Generalized Hermitian.
Definition: MooseTypes.h:875
OutputTools< RealEigenVector >::VariableTestCurl ArrayVariableTestCurl
Definition: MooseTypes.h:363
SolutionIterationType
Definition: MooseTypes.h:241
const BoundaryID ANY_BOUNDARY_ID
Definition: MooseTypes.C:21
unsigned int THREAD_ID
Definition: MooseTypes.h:209
boundary_id_type BoundaryID
Definition: MooseTypes.h:205
Moose::GenericType< RankTwoTensor, is_ad > GenericRankTwoTensor
Definition: MooseTypes.h:657
uint8_t dof_id_type
DualNumber< ADReal, ADReal > ChainedADReal
Definition: ChainedADReal.h:15
const TagName SOLUTION_DOT_TAG
Definition: MooseTypes.C:30