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
245 };
246 
247 // These are used by MooseVariableData and MooseVariableDataFV
249 {
252 };
253 
254 template <typename OutputType>
255 struct ShapeType
256 {
257  typedef OutputType type;
258 };
259 template <>
260 struct ShapeType<Eigen::Matrix<Real, Eigen::Dynamic, 1>>
261 {
262  typedef Real type;
263 };
264 
265 template <typename OutputType>
266 struct DOFType
267 {
268  typedef OutputType type;
269 };
270 template <>
272 {
273  typedef Real type;
274 };
275 } // namespace Moose
276 
277 template <typename OutputType>
279 {
283 
289 
294 
300 
306 
307  // DoF value type for the template class OutputType
310  typedef OutputType OutputValue;
311 };
312 
313 // types for standard variable
329 
330 // types for vector variable
346 
347 // types for array variable
355 typedef std::vector<std::vector<Eigen::Map<RealDIMValue>>> MappedArrayVariablePhiGradient;
364 
381 
382 namespace Moose
383 {
384 
385 // type conversion from regular to AD
386 template <typename T>
387 struct ADType
388 {
389  // unless a specialization exists we assume there is no specific AD type
390  typedef T type;
391 };
392 
393 template <>
394 struct ADType<Real>
395 {
396  typedef ADReal type;
397 };
398 template <>
400 {
402 };
403 template <>
404 struct ADType<Point>
405 {
406  typedef ADPoint type;
407 };
408 
409 template <>
411 {
413 };
414 template <>
416 {
418 };
419 template <>
421 {
423 };
424 template <>
426 {
428 };
429 
430 template <>
432 {
434 };
435 template <>
437 {
439 };
440 
441 template <template <typename T> class W, typename T>
442 struct ADType<W<T>>
443 {
444  typedef W<typename ADType<T>::type> type;
445 };
446 
447 template <typename T>
448 struct ADType<std::vector<T, std::allocator<T>>>
449 {
450  typedef typename ADType<T>::type adT;
451  typedef std::vector<adT, std::allocator<adT>> type;
452 };
453 
454 template <typename T>
455 struct ADType<std::list<T, std::allocator<T>>>
456 {
457  typedef typename ADType<T>::type adT;
458  typedef std::list<adT, std::allocator<adT>> type;
459 };
460 
461 template <typename T>
462 struct ADType<std::set<T, std::less<T>, std::allocator<T>>>
463 {
464  typedef typename ADType<T>::type adT;
465  typedef std::set<adT, std::less<adT>, std::allocator<adT>> type;
466 };
467 
468 template <typename T>
469 struct ADType<DenseVector<T>>
470 {
472 };
473 
474 template <typename T>
475 struct ADType<DenseMatrix<T>>
476 {
478 };
479 
480 template <>
482 {
484 };
485 template <>
487 {
489 };
490 template <>
492 {
494 };
495 template <>
497 {
499 };
500 
501 template <>
502 struct ADType<ADReal>
503 {
504  typedef ADReal type;
505 };
506 template <>
508 {
510 };
511 template <>
513 {
515 };
516 template <>
518 {
520 };
521 template <>
523 {
525 };
526 
527 template <>
529 {
531 };
532 template <>
534 {
536 };
537 
538 template <>
540 {
542 };
543 template <>
545 {
547 };
548 template <>
550 {
552 };
553 
554 template <typename T>
555 struct IsADType
556 {
557  static constexpr bool value = false;
558 };
559 
560 template <>
562 {
563  static constexpr bool value = true;
564 };
565 
566 template <>
568 {
569  static constexpr bool value = true;
570 };
571 
572 template <template <typename T, typename... Args> class W, typename T, typename... Args>
573 struct IsADType<W<T, Args...>>
574 {
575  static constexpr bool value = IsADType<T>::value;
576 };
577 
578 template <typename T, typename... Args>
579 struct IsADType<MetaPhysicL::DualNumber<T, Args...>>
580 {
581  static constexpr bool value = true;
582 };
583 
589 template <class... Ts>
590 constexpr std::false_type always_false{};
591 
592 } // namespace Moose
593 
600 
601 template <typename T>
604 template <typename T>
607 template <typename T>
610 template <typename T>
612 
619 
620 // We can use the non-ad version for test values because these don't depend on the mesh
621 // displacements (unless the location of the quadrature points depend on the mesh displacements...)
622 template <typename T>
624 template <typename T>
626 
627 // We need to use the AD version for test gradients and seconds because these *do* depend on the
628 // mesh displacements
629 template <typename T>
632 template <typename T>
635 template <typename T>
639 
640 // Templated typed to support is_ad templated classes
641 namespace Moose
642 {
643 template <typename T, bool is_ad>
644 using GenericType = typename std::conditional<is_ad, typename ADType<T>::type, T>::type;
645 }
646 
647 template <bool is_ad>
649 template <bool is_ad>
651 template <bool is_ad>
653 template <bool is_ad>
655 template <bool is_ad>
657 template <bool is_ad>
659 template <bool is_ad>
661 template <bool is_ad>
663 template <bool is_ad>
665 template <bool is_ad>
667 template <bool is_ad>
669 template <bool is_ad>
671 template <bool is_ad>
673 
674 namespace Moose
675 {
677 extern const SubdomainID ANY_BLOCK_ID;
678 extern const SubdomainID INVALID_BLOCK_ID;
679 extern const BoundaryID ANY_BOUNDARY_ID;
680 extern const BoundaryID INVALID_BOUNDARY_ID;
681 extern const TagID INVALID_TAG_ID;
682 extern const TagTypeID INVALID_TAG_TYPE_ID;
683 const std::set<SubdomainID> EMPTY_BLOCK_IDS = {};
684 const std::set<BoundaryID> EMPTY_BOUNDARY_IDS = {};
685 
692 {
698 };
699 
704 {
705  PRE_IC = 0,
706  PRE_AUX = 1,
707  POST_AUX = 2,
708  ALL = 3
709 };
710 
715 {
719 };
720 
722 {
728 };
729 
731 {
735 };
736 
738 {
741 };
742 
744 {
747 };
748 
750 {
755 };
756 
758 {
761 };
762 
763 enum class ElementType : unsigned int
764 {
768 };
769 
770 enum class MortarType : unsigned int
771 {
772  Secondary = static_cast<unsigned int>(Moose::ElementType::Element),
773  Primary = static_cast<unsigned int>(Moose::ElementType::Neighbor),
774  Lower = static_cast<unsigned int>(Moose::ElementType::Lower)
775 };
776 
780 enum class ComputeType
781 {
782  Residual,
783  Jacobian,
785 };
786 
791 enum class RESTARTABLE_FILTER : unsigned char
792 {
794 };
795 
797 {
807 };
808 
810 {
814 };
815 
820 {
825 };
826 
831 {
837 };
838 
843 {
849 };
850 
855 {
865 };
866 
871 {
879 };
880 
885 {
897 };
898 
903 {
912 };
913 
918 {
921 };
926 {
937 };
938 
943 {
947 };
948 
953 {
958 };
959 
963 enum class RelationshipManagerType : unsigned char
964 {
965  DEFAULT = 0,
966  GEOMETRIC = 1 << 0,
967  ALGEBRAIC = 1 << 1,
968  COUPLING = 1 << 2
969 };
970 
972 {
976 };
977 
979 {
983 };
984 
988 typedef std::function<void(const InputParameters &, InputParameters &)>
990 
991 std::string stringify(const Moose::RelationshipManagerType & t);
992 std::string stringify(const Moose::TimeIntegratorType & t);
993 } // namespace Moose
994 
995 namespace libMesh
996 {
997 template <>
998 inline void
999 print_helper(std::ostream & os, const Moose::RelationshipManagerType * param)
1000 {
1001  // Specialization so that we don't print out unprintable characters
1002  os << Moose::stringify(*param);
1003 }
1004 
1005 // End of Moose Namespace
1006 }
1007 
1008 template <>
1009 struct enable_bitmask_operators<Moose::RelationshipManagerType>
1010 {
1011  static const bool enable = true;
1012 };
1013 
1022 #define DerivativeStringClass(TheName) \
1023  class TheName : public std::string \
1024  { \
1025  public: \
1026  TheName() : std::string() {} \
1027  TheName(const std::string & str) : std::string(str) {} \
1028  TheName(const std::string & str, size_t pos, size_t n = npos) : std::string(str, pos, n) {} \
1029  TheName(const char * s, size_t n) : std::string(s, n) {} \
1030  TheName(const char * s) : std::string(s) {} \
1031  TheName(size_t n, char c) : std::string(n, c) {} \
1032  }; \
1033  namespace nlohmann \
1034  { \
1035  template <> \
1036  struct adl_serializer<TheName> \
1037  { \
1038  static void to_json(json & j, const TheName & v); \
1039  }; \
1040  } \
1041  static_assert(true, "")
1042 
1043 // Instantiate new Types
1044 
1048 DerivativeStringClass(FileName);
1049 
1051 DerivativeStringClass(FileNameNoExtension);
1052 
1055 DerivativeStringClass(RelativeFileName);
1056 
1059 DerivativeStringClass(DataFileName);
1060 
1062 DerivativeStringClass(MeshFileName);
1063 
1065 DerivativeStringClass(MatrixFileName);
1066 
1068 DerivativeStringClass(OutFileBase);
1069 
1071 DerivativeStringClass(NonlinearVariableName);
1072 
1074 DerivativeStringClass(LinearVariableName);
1075 
1077 DerivativeStringClass(SolverVariableName);
1078 
1080 DerivativeStringClass(AuxVariableName);
1081 
1083 DerivativeStringClass(VariableName);
1084 
1086 DerivativeStringClass(BoundaryName);
1087 
1089 DerivativeStringClass(SubdomainName);
1090 
1092 DerivativeStringClass(PostprocessorName);
1093 
1095 DerivativeStringClass(VectorPostprocessorName);
1096 
1098 DerivativeStringClass(MeshDivisionName);
1099 
1101 DerivativeStringClass(FunctionName);
1102 
1104 DerivativeStringClass(DistributionName);
1105 
1107 DerivativeStringClass(SamplerName);
1108 
1110 DerivativeStringClass(UserObjectName);
1111 
1113 DerivativeStringClass(IndicatorName);
1114 
1116 DerivativeStringClass(MarkerName);
1117 
1119 DerivativeStringClass(MultiAppName);
1120 
1122 DerivativeStringClass(OutputName);
1123 
1125 DerivativeStringClass(MaterialPropertyName);
1126 
1128 DerivativeStringClass(MooseFunctorName);
1129 
1131 DerivativeStringClass(MaterialName);
1132 
1134 DerivativeStringClass(TagName);
1135 
1137 DerivativeStringClass(MeshGeneratorName);
1138 
1140 DerivativeStringClass(ExtraElementIDName);
1141 
1143 DerivativeStringClass(ReporterValueName);
1144 
1146 DerivativeStringClass(ComponentName);
1147 
1149 DerivativeStringClass(PhysicsName);
1150 
1152 DerivativeStringClass(PositionsName);
1153 
1155 DerivativeStringClass(TimesName);
1156 
1158 DerivativeStringClass(ExecutorName);
1159 
1161 DerivativeStringClass(ParsedFunctionExpression);
1162 
1164 DerivativeStringClass(NonlinearSystemName);
1165 
1167 DerivativeStringClass(ConvergenceName);
1168 
1170 DerivativeStringClass(LinearSystemName);
1171 
1173 DerivativeStringClass(SolverSystemName);
1174 
1176 DerivativeStringClass(CLIArgString);
1177 
1178 #ifdef MOOSE_MFEM_ENABLED
1179 
1182 DerivativeStringClass(MFEMScalarCoefficientName);
1184 DerivativeStringClass(MFEMVectorCoefficientName);
1185 DerivativeStringClass(MFEMMatrixCoefficientName);
1187 #endif
1188 
1191 typedef std::vector<VariableName> CoupledName;
1192 namespace Moose
1193 {
1194 extern const TagName SOLUTION_TAG;
1195 extern const TagName OLD_SOLUTION_TAG;
1196 extern const TagName OLDER_SOLUTION_TAG;
1197 extern const TagName PREVIOUS_NL_SOLUTION_TAG;
1198 
1199 enum class FEBackend
1200 {
1201  LibMesh
1202 #ifdef MOOSE_MFEM_ENABLED
1203  ,
1204  MFEM
1205 #endif
1206 };
1207 }
1208 
1210 #define usingTensorIndices(...) \
1211  enum \
1212  { \
1213  __VA_ARGS__ \
1214  }
ConstraintFormulationType
Type of constraint formulation.
Definition: MooseTypes.h:917
typename OutputTools< typename Moose::ADType< T >::type >::VariableSecond ADTemplateVariableSecond
Definition: MooseTypes.h:609
OutputTools< Real >::VariableGradient VariableGradient
Definition: MooseTypes.h:315
VarFieldType
Definition: MooseTypes.h:721
RankFourTensorTempl is designed to handle any N-dimensional fourth order tensor, C.
Generalized Non-Hermitian.
Definition: MooseTypes.h:876
OutputTools< RealVectorValue >::VariableDivergence VectorVariableDivergence
Definition: MooseTypes.h:335
RealVectorValue RealGradient
Moose::GenericType< Real, is_ad > GenericReal
Definition: MooseTypes.h:648
typename OutputTools< typename Moose::ADType< T >::type >::VariableCurl ADTemplateVariableCurl
Definition: MooseTypes.h:611
Moose::GenericType< VectorVariableValue, is_ad > GenericVectorVariableValue
Definition: MooseTypes.h:664
unsigned int TagTypeID
Definition: MooseTypes.h:211
Generalized Hermitian indefinite.
Definition: MooseTypes.h:875
OutputTools< RealVectorValue >::VariableSecond VectorVariableSecond
Definition: MooseTypes.h:333
Newton-based eigensolver with an assembled Jacobian matrix (fully coupled by default) ...
Definition: MooseTypes.h:861
Full Newton Solve.
Definition: MooseTypes.h:846
OutputTools< RealEigenVector >::VariableDivergence ArrayVariableDivergence
Definition: MooseTypes.h:352
typename OutputTools< typename Moose::ADType< T >::type >::VariablePhiGradient ADTemplateVariablePhiGradient
Definition: MooseTypes.h:637
ConstraintType
Definition: MooseTypes.h:757
smallest magnitude
Definition: MooseTypes.h:887
libMesh::DenseMatrix< ADReal > ADDenseMatrix
Definition: MooseTypes.h:372
const TagTypeID INVALID_TAG_TYPE_ID
Definition: MooseTypes.C:24
libMesh::TensorTools::IncrementRank< OutputGradient >::type OutputSecond
Definition: MooseTypes.h:281
EigenSolveType
Type of the eigen solve.
Definition: MooseTypes.h:854
RelationshipManagerType
Main types of Relationship Managers.
Definition: MooseTypes.h:963
void print_helper(std::ostream &os, const P *param)
OutputTools< Real >::VariableTestDivergence VariableTestDivergence
Definition: MooseTypes.h:328
std::set< adT, std::less< adT >, std::allocator< adT > > type
Definition: MooseTypes.h:465
unsigned int TagID
Definition: MooseTypes.h:210
unsigned int InvalidSolutionID
Definition: MooseTypes.h:213
MooseArray< std::vector< OutputShapeGradient > > VariablePhiGradient
Definition: MooseTypes.h:296
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:634
OutputTools< RealVectorValue >::VariableTestCurl VectorVariableTestCurl
Definition: MooseTypes.h:344
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:471
MooseArray< std::vector< OutputShapeDivergence > > VariablePhiDivergence
Definition: MooseTypes.h:299
MooseArray< std::vector< OutputShapeDivergence > > VariableTestDivergence
Definition: MooseTypes.h:305
OutputType type
Definition: MooseTypes.h:268
OutputType type
Definition: MooseTypes.h:257
OutputTools< RealEigenVector >::VariablePhiValue ArrayVariablePhiValue
Definition: MooseTypes.h:353
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:623
The same as PJFNK except that matrix-vector multiplication is employed to replace residual evaluation...
Definition: MooseTypes.h:863
MortarType
Definition: MooseTypes.h:770
MooseArray< std::vector< OutputShape > > VariableTestValue
Definition: MooseTypes.h:301
VariableTestGradient ADVariableTestGradient
Definition: MooseTypes.h:614
OutputTools< RealVectorValue >::VariableValue VectorVariableValue
Definition: MooseTypes.h:331
libMesh::DenseVector< ADReal > ADDenseVector
Definition: MooseTypes.h:373
MaterialDataType
MaterialData types.
Definition: MooseTypes.h:691
MooseArray< std::vector< OutputShapeGradient > > VariableTestGradient
Definition: MooseTypes.h:302
OutputType OutputValue
Definition: MooseTypes.h:310
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:590
MooseArray< ADRealVectorValue > ADVariableGradient
Definition: MooseTypes.h:375
typename OutputTools< T >::VariablePhiValue ADTemplateVariablePhiValue
Definition: MooseTypes.h:625
DenseMatrix< typename ADType< T >::type > type
Definition: MooseTypes.h:477
OutputTools< RealVectorValue >::VariableTestValue VectorVariableTestValue
Definition: MooseTypes.h:341
libMesh::StoredRange< std::vector< dof_id_type >::iterator, dof_id_type > NodeIdRange
Definition: MooseTypes.h:216
MooseArray< ADRealVectorValue > ADVectorVariableCurl
Definition: MooseTypes.h:380
typename OutputTools< typename Moose::ADType< T >::type >::VariableValue ADTemplateVariableValue
Definition: MooseTypes.h:603
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system...
OutputTools< RealEigenVector >::VariableCurl ArrayVariableCurl
Definition: MooseTypes.h:351
ADTemplateVariablePhiGradient< Real > ADVariablePhiGradient
Definition: MooseTypes.h:638
Solving a linear problem.
Definition: MooseTypes.h:848
OutputTools< RealEigenVector >::VariableSecond ArrayVariableSecond
Definition: MooseTypes.h:350
OutputTools< Real >::VariablePhiValue VariablePhiValue
Definition: MooseTypes.h:319
MooseArray< OutputData > DoFValue
Definition: MooseTypes.h:309
OutputTools< RealVectorValue >::VariableCurl VectorVariableCurl
Definition: MooseTypes.h:334
use whatever SLPEC has by default
Definition: MooseTypes.h:878
OutputTools< RealVectorValue >::VariablePhiGradient VectorVariablePhiGradient
Definition: MooseTypes.h:337
target magnitude
Definition: MooseTypes.h:892
OutputTools< RealEigenVector >::VariablePhiSecond ArrayVariablePhiSecond
Definition: MooseTypes.h:356
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:654
The following methods are specializations for using the libMesh::Parallel::packed_range_* routines fo...
ElementType
Definition: MooseTypes.h:763
std::basic_ostream< charT, traits > * os
Definition: InfixIterator.h:33
DGResidualType
Definition: MooseTypes.h:743
libMesh::TensorValue< ADReal > ADRealTensorValue
Definition: MooseTypes.h:371
DualNumber< Real, DNDerivativeType, true > ADReal
Definition: ADRealForward.h:46
Moose::GenericType< DenseVector< Real >, is_ad > GenericDenseVector
Definition: MooseTypes.h:670
Generalized Non-Hermitian with positive (semi-)definite B.
Definition: MooseTypes.h:877
MooseArray< OutputType > VariableValue
Definition: MooseTypes.h:284
MooseArray< libMesh::TypeNTensor< 3, ADReal > > ADVectorVariableSecond
Definition: MooseTypes.h:379
MffdType
Type of the matrix-free finite-differencing parameter.
Definition: MooseTypes.h:942
Moose::GenericType< RankFourTensor, is_ad > GenericRankFourTensor
Definition: MooseTypes.h:660
VectorVariableTestSecond ADVectorVariableTestSecond
Definition: MooseTypes.h:618
OutputTools< Real >::VariablePhiSecond VariablePhiSecond
Definition: MooseTypes.h:321
Power / Inverse / RQI.
Definition: MooseTypes.h:856
typename std::conditional< is_ad, typename ADType< T >::type, T >::type GenericType
Definition: MooseTypes.h:644
Krylov-Schur.
Definition: MooseTypes.h:858
unsigned int PerfID
Definition: MooseTypes.h:212
AuxGroup
Flag for AuxKernel related execution type.
Definition: MooseTypes.h:703
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:374
VariableTestSecond ADVariableTestSecond
Definition: MooseTypes.h:615
MooseKSPNormType
Norm type for converge test.
Definition: MooseTypes.h:830
const SubdomainID INVALID_BLOCK_ID
Definition: MooseTypes.C:20
libMesh::TensorTools::IncrementRank< OutputShapeGradient >::type OutputShapeSecond
Definition: MooseTypes.h:292
MooseArray< std::vector< OutputShape > > VariablePhiValue
Definition: MooseTypes.h:295
OutputTools< RealVectorValue >::VariablePhiDivergence VectorVariablePhiDivergence
Definition: MooseTypes.h:340
TensorValue< Real > RealTensorValue
uint8_t processor_id_type
libMesh::TensorTools::IncrementRank< OutputType >::type OutputGradient
Definition: MooseTypes.h:280
libMesh::TensorTools::DecrementRank< OutputType >::type OutputDivergence
Definition: MooseTypes.h:282
std::remove_const< T >::type _MooseIndex(T, int)
Definition: MooseTypes.h:113
Use whatever we have in PETSc.
Definition: MooseTypes.h:824
Preconditioned Jacobian-free Newton Krylov.
Definition: MooseTypes.h:862
WhichEigenPairs
Which eigen pairs.
Definition: MooseTypes.h:884
int8_t boundary_id_type
OutputTools< RealEigenVector >::VariableTestDivergence ArrayVariableTestDivergence
Definition: MooseTypes.h:363
OutputTools< RealEigenVector >::VariableValue ArrayVariableValue
Definition: MooseTypes.h:348
OutputTools< RealVectorValue >::VariableTestDivergence VectorVariableTestDivergence
Definition: MooseTypes.h:345
MooseArray< ADRealTensorValue > ADVectorVariableGradient
Definition: MooseTypes.h:378
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
OutputTools< Real >::VariableCurl VariableCurl
Definition: MooseTypes.h:317
LineSearchType
Type of the line search.
Definition: MooseTypes.h:925
RESTARTABLE_FILTER
The filter type applied to a particular piece of "restartable" data.
Definition: MooseTypes.h:791
Moose::GenericType< VariableValue, is_ad > GenericVariableValue
Definition: MooseTypes.h:662
const TagName OLD_SOLUTION_TAG
Definition: MooseTypes.C:26
Use whatever we have in PETSc.
Definition: MooseTypes.h:836
Moose::GenericType< VariableGradient, is_ad > GenericVariableGradient
Definition: MooseTypes.h:666
std::function< void(const InputParameters &, InputParameters &)> RelationshipManagerInputParameterCallback
The type for the callback to set RelationshipManager parameters.
Definition: MooseTypes.h:989
libMesh::VectorValue< ADReal > ADPoint
Definition: MooseTypes.h:370
OutputTools< RealVectorValue >::VariablePhiSecond VectorVariablePhiSecond
Definition: MooseTypes.h:338
OutputTools< Real >::VariableTestValue VariableTestValue
Definition: MooseTypes.h:324
boundary_id_type BoundaryID
VarKindType
Framework-wide stuff.
Definition: MooseTypes.h:714
Jacobian-Free Newton Krylov.
Definition: MooseTypes.h:845
std::vector< std::vector< Eigen::Map< RealDIMValue > > > MappedArrayVariablePhiGradient
Definition: MooseTypes.h:355
Real PostprocessorValue
various MOOSE typedefs
Definition: MooseTypes.h:202
typename OutputTools< typename Moose::ADType< T >::type >::VariableTestGradient ADTemplateVariableTestGradient
Definition: MooseTypes.h:631
ADSymmetricRankFourTensor type
Definition: MooseTypes.h:438
OutputTools< Real >::VariableDivergence VariableDivergence
Definition: MooseTypes.h:318
NumberVectorValue Gradient
MooseArray< std::vector< OutputShape > > VariableTestCurl
Definition: MooseTypes.h:304
MooseArray< OutputSecond > VariableSecond
Definition: MooseTypes.h:286
unsigned int InterfaceID
Definition: MooseTypes.h:206
Moose::ShapeType< OutputType >::type OutputShape
Definition: MooseTypes.h:290
typename OutputTools< typename Moose::ADType< T >::type >::VariableGradient ADTemplateVariableGradient
Definition: MooseTypes.h:606
target imaginary
Definition: MooseTypes.h:894
OutputTools< Real >::VariablePhiCurl VariablePhiCurl
Definition: MooseTypes.h:322
MooseArray< OutputGradient > VariableGradient
Definition: MooseTypes.h:285
Use finite differences to compute Jacobian.
Definition: MooseTypes.h:847
MooseArray< OutputType > VariableCurl
Definition: MooseTypes.h:287
Moose::GenericType< RealVectorValue, is_ad > GenericRealVectorValue
Definition: MooseTypes.h:652
Moose::GenericType< ChainedReal, is_ad > GenericChainedReal
Definition: MooseTypes.h:650
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:860
OutputTools< Real >::VariablePhiDivergence VariablePhiDivergence
Definition: MooseTypes.h:323
VectorTagType
Definition: MooseTypes.h:978
ComputeType
The type of nonlinear computation being performed.
Definition: MooseTypes.h:780
Jacobi-Davidson.
Definition: MooseTypes.h:859
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:314
DGJacobianType
Definition: MooseTypes.h:749
ConstraintSideType
Definition: MooseTypes.h:737
std::vector< Real > VectorPostprocessorValue
Definition: MooseTypes.h:203
Real ScatterVectorPostprocessorValue
Definition: MooseTypes.h:204
OutputTools< Real >::VariablePhiGradient VariablePhiGradient
Definition: MooseTypes.h:320
std::list< adT, std::allocator< adT > > type
Definition: MooseTypes.h:458
MooseArray< std::vector< OutputShapeSecond > > VariablePhiSecond
Definition: MooseTypes.h:297
MooseArray< std::vector< OutputShape > > VariablePhiCurl
Definition: MooseTypes.h:298
const SubdomainID ANY_BLOCK_ID
Definition: MooseTypes.C:19
forward declarations
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
const std::set< SubdomainID > EMPTY_BLOCK_IDS
Definition: MooseTypes.h:683
OutputTools< Real >::VariableTestSecond VariableTestSecond
Definition: MooseTypes.h:326
OutputTools< RealVectorValue >::VariableTestGradient VectorVariableTestGradient
Definition: MooseTypes.h:342
OutputTools< RealVectorValue >::VariablePhiValue VectorVariablePhiValue
Definition: MooseTypes.h:336
GeometryType
Definition: MooseTypes.h:248
OutputTools< RealEigenVector >::VariableTestSecond ArrayVariableTestSecond
Definition: MooseTypes.h:361
CoordinateSystemType
Definition: MooseTypes.h:809
smallest imaginary
Definition: MooseTypes.h:891
std::string RestartableDataMapName
Definition: MooseTypes.h:214
VectorVariableTestValue ADVectorVariableTestValue
Definition: MooseTypes.h:616
const std::set< BoundaryID > EMPTY_BOUNDARY_IDS
Definition: MooseTypes.h:684
const TagID INVALID_TAG_ID
Definition: MooseTypes.C:23
std::vector< VariableName > CoupledName
additional MOOSE typedefs
Definition: MooseTypes.h:1191
RMSystemType
Definition: MooseTypes.h:971
OutputTools< RealVectorValue >::VariableTestSecond VectorVariableTestSecond
Definition: MooseTypes.h:343
SolutionState
Definition: MooseTypes.h:233
Jacobian-free Newton Krylov.
Definition: MooseTypes.h:864
means not set
Definition: MooseTypes.h:944
PatchUpdateType
Type of patch update strategy for modeling node-face constraints or contact.
Definition: MooseTypes.h:952
MooseArray< std::vector< OutputShapeSecond > > VariableTestSecond
Definition: MooseTypes.h:303
ConstraintJacobianType
Definition: MooseTypes.h:796
OutputTools< RealEigenVector >::VariablePhiDivergence ArrayVariablePhiDivergence
Definition: MooseTypes.h:358
SymmetricRankFourTensorTempl is designed to handle an N-dimensional fourth order tensor with minor sy...
largest imaginary
Definition: MooseTypes.h:890
libMesh::TensorTools::DecrementRank< OutputShape >::type OutputShapeDivergence
Definition: MooseTypes.h:293
OutputTools< RealEigenVector >::VariablePhiCurl ArrayVariablePhiCurl
Definition: MooseTypes.h:357
Non-Hermitian.
Definition: MooseTypes.h:873
CouplingType
Definition: MooseTypes.h:730
OutputTools< RealEigenVector >::VariablePhiGradient ArrayVariablePhiGradient
Definition: MooseTypes.h:354
TimeIntegratorType
Time integrators.
Definition: MooseTypes.h:902
MooseArray< ADRealTensorValue > ADVariableSecond
Definition: MooseTypes.h:376
DerivativeStringClass(FileName)
This type is for expected (i.e.
PCSideType
Preconditioning side.
Definition: MooseTypes.h:819
ADRealVectorValue ADRealGradient
Definition: MooseTypes.h:369
VectorVariableTestGradient ADVectorVariableTestGradient
Definition: MooseTypes.h:617
Moose::DOFType< OutputType >::type OutputData
Definition: MooseTypes.h:308
VariableTestValue ADVariableTestValue
Definition: MooseTypes.h:613
all eigenvalues
Definition: MooseTypes.h:895
Moose::GenericType< RankThreeTensor, is_ad > GenericRankThreeTensor
Definition: MooseTypes.h:658
Moose::GenericType< VariableSecond, is_ad > GenericVariableSecond
Definition: MooseTypes.h:668
const TagName SOLUTION_TAG
Definition: MooseTypes.C:25
OutputTools< Real >::VariableSecond VariableSecond
Definition: MooseTypes.h:316
Eigen::Matrix< Real, Eigen::Dynamic, 1 > RealEigenVector
Definition: MooseTypes.h:146
Preconditioned Jacobian-Free Newton Krylov.
Definition: MooseTypes.h:844
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:339
MooseArray< OutputDivergence > VariableDivergence
Definition: MooseTypes.h:288
use whatever we have in SLEPC
Definition: MooseTypes.h:896
OutputTools< RealVectorValue >::VariableGradient VectorVariableGradient
Definition: MooseTypes.h:332
means not set
Definition: MooseTypes.h:927
libMesh::StoredRange< std::vector< const Elem * >::iterator, const Elem * > ConstElemPointerRange
Definition: MooseTypes.h:218
largest magnitude
Definition: MooseTypes.h:886
Eigen::Matrix< Real, Eigen::Dynamic, Moose::dim *Moose::dim > RealTensorArrayValue
Definition: MooseTypes.h:148
std::vector< adT, std::allocator< adT > > type
Definition: MooseTypes.h:451
OutputTools< Real >::VariableTestCurl VariableTestCurl
Definition: MooseTypes.h:327
OutputTools< RealEigenVector >::VariableTestValue ArrayVariableTestValue
Definition: MooseTypes.h:359
SolveType
Type of the solve.
Definition: MooseTypes.h:842
OutputTools< Real >::VariableTestGradient VariableTestGradient
Definition: MooseTypes.h:325
W< typename ADType< T >::type > type
Definition: MooseTypes.h:444
OutputTools< RealEigenVector >::VariableGradient ArrayVariableGradient
Definition: MooseTypes.h:349
const TagName PREVIOUS_NL_SOLUTION_TAG
Definition: MooseTypes.C:28
static constexpr bool value
Definition: MooseTypes.h:557
unsigned int MooseObjectID
Definition: MooseTypes.h:208
libMesh::VectorValue< ADReal > ADRealVectorValue
AD typedefs.
Definition: MooseTypes.h:368
MooseArray< ADRealVectorValue > ADVectorVariableValue
Definition: MooseTypes.h:377
OutputTools< RealEigenVector >::VariableTestGradient ArrayVariableTestGradient
Definition: MooseTypes.h:360
libMesh::TensorTools::IncrementRank< OutputShape >::type OutputShapeGradient
Definition: MooseTypes.h:291
EigenProblemType
Type of the eigen problem.
Definition: MooseTypes.h:870
ADSymmetricRankTwoTensor type
Definition: MooseTypes.h:433
Moose::GenericType< DenseMatrix< Real >, is_ad > GenericDenseMatrix
Definition: MooseTypes.h:672
void ErrorVector unsigned int
Generalized Hermitian.
Definition: MooseTypes.h:874
OutputTools< RealEigenVector >::VariableTestCurl ArrayVariableTestCurl
Definition: MooseTypes.h:362
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:656
uint8_t dof_id_type
DualNumber< ADReal, ADReal > ChainedADReal
Definition: ChainedADReal.h:15