Moose Namespace Reference

MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to address this in their environment if C++17 compatibility isn't found. More...

Namespaces
namespace	DataFileUtils
namespace	FV
namespace	internal
namespace	Kokkos
namespace	MFEM
	Utilities for converting between vector(s) of libMesh Points and MFEM Vector(s).
namespace	Mortar
namespace	ParameterRegistration
namespace	PetscSupport
namespace	SlepcSupport
namespace	UnitUtils
namespace	WebServerControlTypeRegistration
	Defines classes for registering values that can be parsed, communicated, and stored in the WebServerControl.

Classes
struct	_enumerate_iterator
struct	_enumerate_range
struct	_enumerate_struct
struct	ADType
struct	ADType< ADRankFourTensor >
struct	ADType< ADRankThreeTensor >
struct	ADType< ADRankTwoTensor >
struct	ADType< ADReal >
struct	ADType< ADSymmetricRankFourTensor >
struct	ADType< ADSymmetricRankTwoTensor >
struct	ADType< ADVariableGradient >
struct	ADType< ADVariableSecond >
struct	ADType< ADVariableValue >
struct	ADType< ChainedADReal >
struct	ADType< ChainedReal >
struct	ADType< DenseMatrix< T > >
struct	ADType< DenseVector< T > >
struct	ADType< Eigen::Matrix< T, M, N, O, M2, N2 > >
struct	ADType< Point >
struct	ADType< RankFourTensor >
struct	ADType< RankThreeTensor >
struct	ADType< RankTwoTensor >
struct	ADType< Real >
struct	ADType< RealEigenMatrix >
struct	ADType< RealEigenVector >
struct	ADType< RealVectorValue >
struct	ADType< std::list< T, std::allocator< T > > >
struct	ADType< std::set< T, std::less< T >, std::allocator< T > > >
struct	ADType< std::vector< T, std::allocator< T > > >
struct	ADType< SymmetricRankFourTensor >
struct	ADType< SymmetricRankTwoTensor >
struct	ADType< VariableGradient >
struct	ADType< VariableSecond >
struct	ADType< VariableValue >
struct	ADType< W< T > >
class	ADWrapperFunctor
	Wraps non-AD functors such that they can be used in objects that have requested the functor as AD. More...
class	ArrayComponentFunctor
	This is essentially a forwarding functor that forwards the spatial and temporal evaluation arguments to the parent array functor and then returns the result indexed at a given component. More...
class	BSpline
	Class implementing a uniform clamped B-Spline curve. More...
class	Builder
	Parses MOOSE input using HIT/WASP. More...
class	Capability
	An entry for a single capability. More...
class	CapabilityException
	Common execption to be thrown when interacting with capabilities. More...
class	ConstantFunctor
	Class template for creating constant functors. More...
struct	DerivativeStringClass
	Struct that all MOOSE derivative strings derive from. More...
struct	DOFType
struct	DOFType< RealVectorValue >
struct	ElemArg
	A structure that is used to evaluate Moose functors logically at an element/cell center. More...
struct	ElemPointArg
	A structure that is used to evaluate Moose functors at an arbitrary physical point contained within an element. More...
struct	ElemQpArg
	Argument for requesting functor evaluation at a quadrature point location in an element. More...
struct	ElemSideQpArg
	Argument for requesting functor evaluation at quadrature point locations on an element side. More...
struct	FaceArg
	A structure defining a "face" evaluation calling argument for Moose functors. More...
class	FunctionBase
class	FunctorAbstract
	Abstract base class that can be used to hold collections of functors. More...
class	FunctorBase
	Base class template for functor objects. More...
class	FunctorEnvelope
	This is a wrapper that forwards calls to the implementation, which can be switched out at any time without disturbing references to FunctorBase. More...
class	FunctorEnvelopeBase
	A non-templated base class for functors that allow an owner object to hold different class template instantiations of Functor in a single container. More...
struct	FunctorGradientEvaluationKind
	This structure takes an evaluation kind as a template argument and defines a constant expression indicating the associated gradient kind. More...
struct	FunctorGradientEvaluationKind< FunctorEvaluationKind::Dot >
	The gradient kind associated with a time derivative is the gradient of the time derivative. More...
struct	FunctorGradientEvaluationKind< FunctorEvaluationKind::Value >
	The gradient kind associated with a value is simply the gradient. More...
struct	FunctorReturnType
	A structure that defines the return type of a functor based on the type of the functor and the requested evaluation kind, e.g. More...
struct	FunctorReturnType< T, FunctorEvaluationKind::Dot >
	The return type of a time derivative evaluation is the same as the value type. More...
struct	FunctorReturnType< T, FunctorEvaluationKind::GradDot >
	The return type of a gradient of time derivative evaluation is the same as the gradient type. More...
struct	FunctorReturnType< T, FunctorEvaluationKind::Gradient >
	The return type of a gradient evaluation is the rank increment of a value return type. More...
struct	FunctorReturnType< T, FunctorEvaluationKind::Value >
	The return type for a value evaluation is just the type of the functor. More...
struct	indirect_comparator
struct	IsADType
struct	IsADType< ADPoint >
struct	IsADType< ADReal >
struct	IsADType< MetaPhysicL::DualNumber< T, Args... > >
struct	IsADType< W< T, Args... > >
class	LibtorchArtificialNeuralNet
class	LibtorchArtificialNeuralNetTrainer
	Templated class which is responsible for training LibtorchArtificialNeuralNets. More...
class	LibtorchDataset
	This class is a wrapper around a libtorch dataset which can be used by the data loaders in the neural net training process. More...
class	LibtorchNeuralNetBase
	This base class is meant to gather the functions and members common in every neural network based on Libtorch. More...
struct	LibtorchTrainingOptions
	A struct containing necessary information for training neural networks. More...
struct	NodeArg
class	NullFunctor
	A functor that serves as a placeholder during the simulation setup phase if a functor consumer requests a functor that has not yet been constructed. More...
class	ParameterRegistry
	Registry that allows for the typeless setting of a parameter value from a hit field. More...
class	PassKey
class	PeriodicBCHelper
	Helper class for setting up periodic boundary conditions via an Action. More...
class	RawValueFunctor
class	ScopedCommSwapper
class	ScopedDeprecatedIsError
	Scoped helper for setting Moose::_deprecated_is_error during this scope. More...
class	ScopedThrowOnError
	Scoped helper for setting Moose::_throw_on_error during this scope. More...
struct	SerialAccess
	Serial access requires object data to be stored contiguously. More...
class	SerialAccessRange
struct	SerialAccessValueTypeHelper
	Value type helper (necessary for any type that does not have a value_type member or where value_type doesn't have a suitable meaning (ADReal)). More...
struct	SerialAccessValueTypeHelper< ADReal >
struct	SerialAccessValueTypeHelper< Real >
struct	ShapeType
struct	ShapeType< Eigen::Matrix< Real, Eigen::Dynamic, 1 > >
class	Span
	Replacement for std::span which we only get in c++20. More...
struct	StateArg
	State argument for evaluating functors. More...
class	TorchScriptModule
struct	TypeList
	Helper structure to hold a list of types. More...
class	UnknownCapabilitiesException
	Exception thrown when capabilities are unknown. More...
class	UnusedWalker
class	VectorComponentFunctor
	This is essentially a forwarding functor that forwards the spatial and temporal evaluation arguments to the parent vector functor and then returns the result indexed at a given component. More...
class	VectorCompositeFunctor
	A functor that returns a vector composed of its component functor evaluations. More...
class	WebServerControlTypeRegistry
	A static registry used to register and build values of different types for the WebServerControl. More...

Typedefs
template<typename T >
using	Functor = FunctorEnvelope< T >
template<typename T , bool is_ad>
using	GenericType = typename std::conditional< is_ad, typename ADType< T >::type, T >::type
typedef std::function< void(const InputParameters &, InputParameters &)>	RelationshipManagerInputParameterCallback
	The type for the callback to set RelationshipManager parameters.

Enumerations
enum class	FunctorEvaluationKind { Value , Gradient , Dot , GradDot }
	An enumeration of possible functor evaluation kinds. More...
enum	SolutionState : int { Current = 0 , Old = 1 , Older = 2 , PreviousNL = -1 }
enum class	SolutionIterationType : unsigned short {   Time = 0 , Nonlinear , MultiAppFixedPoint , MultiSystemFixedPoint ,   Count }
enum	GeometryType { Volume , Face }
enum	MaterialDataType {   BLOCK_MATERIAL_DATA , BOUNDARY_MATERIAL_DATA , FACE_MATERIAL_DATA , NEIGHBOR_MATERIAL_DATA ,   INTERFACE_MATERIAL_DATA }
	MaterialData types. More...
enum	AuxGroup { PRE_IC = 0 , PRE_AUX = 1 , POST_AUX = 2 , ALL = 3 }
	Flag for AuxKernel related execution type. More...
enum	VarKindType { VAR_SOLVER , VAR_AUXILIARY , VAR_ANY }
	Framework-wide stuff. More...
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 }
	The type of nonlinear computation being performed. More...
enum class	RESTARTABLE_FILTER : unsigned char { RECOVERABLE }
	The filter type applied to a particular piece of "restartable" data. More...
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 }
	Preconditioning side. More...
enum	MooseKSPNormType {   KSPN_NONE , KSPN_PRECONDITIONED , KSPN_UNPRECONDITIONED , KSPN_NATURAL ,   KSPN_DEFAULT }
	Norm type for converge test. More...
enum	SolveType {   ST_PJFNK , ST_JFNK , ST_NEWTON , ST_FD ,   ST_LINEAR }
	Type of the solve. More...
enum	EigenSolveType {   EST_POWER , EST_ARNOLDI , EST_KRYLOVSCHUR , EST_JACOBI_DAVIDSON ,   EST_NONLINEAR_POWER , EST_NEWTON , EST_PJFNK , EST_PJFNKMO ,   EST_JFNK }
	Type of the eigen solve. More...
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 }
	Type of the eigen problem. More...
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 }
	Which eigen pairs. More...
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 }
	Time integrators. More...
enum	ConstraintFormulationType { Penalty , Kinematic }
	Type of constraint formulation. More...
enum	LineSearchType {   LS_INVALID , LS_DEFAULT , LS_NONE , LS_BASIC ,   LS_SHELL , LS_CONTACT , LS_PROJECT , LS_L2 ,   LS_BT , LS_CP }
	Type of the line search. More...
enum	MffdType { MFFD_INVALID , MFFD_WP , MFFD_DS }
	Type of the matrix-free finite-differencing parameter. More...
enum	PatchUpdateType { Never , Always , Auto , Iteration }
	Type of patch update strategy for modeling node-face constraints or contact. More...
enum class	RelationshipManagerType : unsigned char { DEFAULT = 0 , GEOMETRIC = 1 << 0 , ALGEBRAIC = 1 << 1 , COUPLING = 1 << 2 }
	Main types of Relationship Managers. More...
enum	RMSystemType { NONLINEAR , AUXILIARY , NONE }
enum	VectorTagType { VECTOR_TAG_RESIDUAL = 0 , VECTOR_TAG_SOLUTION = 1 , VECTOR_TAG_ANY = 2 }
enum class	FEBackend { LibMesh , MFEM }

Functions
InputParameters	commonAdaptivityParams ()
bool	isSolverExecFlag (const ExecFlagType &exec_flag)
bool	colorConsole ()
	Returns whether Console coloring is turned on (default: true).
bool	setColorConsole (bool use_color, bool force=false)
	Turns color escape sequences on/off for info written to stdout.
void	registerAll (Factory &f, ActionFactory &af, Syntax &s)
	Register objects that are in MOOSE.
void	registerObjects (Factory &factory, const std::set< std::string > &obj_labels)
void	addActionTypes (Syntax &syntax)
void	registerActions (Syntax &syntax, ActionFactory &action_factory)
	Multiple Action class can be associated with a single input file section, in which case all associated Actions will be created and "acted" on when the associated input file section is seen.
void	registerActions (Syntax &syntax, ActionFactory &action_factory, const std::set< std::string > &obj_labels)
void	associateSyntax (Syntax &syntax, ActionFactory &action_factory)
void	setSolverDefaults (FEProblemBase &problem)
MPI_Comm	swapLibMeshComm (MPI_Comm new_comm)
	Swap the libMesh MPI communicator out for ours.
std::string	hitMessagePrefix (const hit::Node &node)
	Get the prefix to be associated with a hit node for a message.
StateArg	currentState ()
StateArg	oldState ()
StateArg	previousNonlinearState ()
StateArg	previousMultiAppFixedPointState ()
StateArg	previousMultiSystemFixedPointState ()
std::unique_ptr< MooseApp >	createMooseApp (const std::string &default_app_type, int argc, char *argv[])
	Create a MooseApp from command-line arguments.
template<typename DefaultAppType >
int	main (int argc, char *argv[])
	Initialize, create and run a MooseApp.
void	findContactPoint (PenetrationInfo &p_info, libMesh::FEBase *fe_elem, libMesh::FEBase *fe_side, libMesh::FEType &fe_side_type, const libMesh::Point &secondary_point, bool start_with_centroid, const Real tangential_tolerance, bool &contact_point_on_side, bool &search_succeeded)
void	restrictPointToFace (libMesh::Point &p, const libMesh::Elem *side, std::vector< const libMesh::Node * > &off_edge_nodes)
void	to_json (nlohmann::json &json, const Moose::LibtorchArtificialNeuralNet *const &network)
void	initial_condition (libMesh::EquationSystems &es, const std::string &system_name)
void	assemble_matrix (EquationSystems &es, const std::string &system_name)
template<std::size_t N>
void	derivInsert (SemiDynamicSparseNumberArray< Real, libMesh::dof_id_type, NWrapper< N > > &derivs, libMesh::dof_id_type index, Real value)
bool	globalADIndexing ()
	Whether we are using global AD indexing.
std::size_t	adOffset (unsigned int var_num, std::size_t max_dofs_per_elem, ElementType element_type=ElementType::Element, unsigned int num_vars_in_system=0)
	Helper function for computing automatic differentiation offset.
std::size_t	adOffset (unsigned int var_num, std::size_t max_dofs_per_elem, DGJacobianType dg_jacobian_type, unsigned int num_vars_in_system=0)
std::unordered_map< dof_id_type, Real >	globalDofIndexToDerivative (const ADReal &ad_real, const SystemBase &sys, ElementType elem_type=ElementType::Element, THREAD_ID tid=0)
	Generate a map from global dof index to derivative value.
template<typename T >
auto	globalDofIndexToDerivative (const T &ad_real_container, const SystemBase &sys, ElementType elem_type=ElementType::Element, THREAD_ID tid=0) -> std::vector< std::unordered_map< dof_id_type, typename std::enable_if< std::is_same< ADReal, typename T::value_type >::value, Real >::type > >
	Generate a map from global dof index to derivative value for a (probably quadrature-point-based) container like a material property or a variable value.
bool	doDerivatives (const SubProblem &subproblem, const SystemBase &sys)
template<bool is_ad>
GenericReal< is_ad >	ADRealToGenericReal (const ADReal &u_ad)
	Converts an ADReal to a GenericReal<is_ad>
template<typename T >
T	stringToEnum (const std::string &s)
template<>
libMesh::QuadratureType	stringToEnum< libMesh::QuadratureType > (const std::string &s)
template<>
libMesh::Order	stringToEnum< libMesh::Order > (const std::string &s)
template<>
CoordinateSystemType	stringToEnum< CoordinateSystemType > (const std::string &s)
template<>
SolveType	stringToEnum< SolveType > (const std::string &s)
template<>
LineSearchType	stringToEnum< LineSearchType > (const std::string &s)
template<>
TimeIntegratorType	stringToEnum< TimeIntegratorType > (const std::string &s)
template<>
RelationshipManagerType	stringToEnum< RelationshipManagerType > (const std::string &s)
template<typename T >
std::vector< T >	vectorStringsToEnum (const MultiMooseEnum &v)
template<typename T >
std::string	stringify (const T &t)
	conversion to string
std::string	stringify (bool v)
std::string	stringify (int v)
std::string	stringify (long v)
std::string	stringify (long long v)
std::string	stringify (unsigned int v)
std::string	stringify (unsigned long v)
std::string	stringify (unsigned long long v)
template<typename... T>
std::string	stringify (std::variant< T... > v)
std::string	stringify (const SolveType &t)
	Convert solve type into human readable string.
std::string	stringify (const EigenSolveType &t)
	Convert eigen solve type into human readable string.
std::string	stringify (const VarFieldType &t)
	Convert variable field type into human readable string.
std::string	stringify (const std::string &s)
	Add no-op stringify if the argument already is a string (must use overloading)
std::string	stringify (libMesh::FEFamily f)
	Convert FEType from libMesh into string.
std::string	stringify (SolutionIterationType t)
	Convert SolutionIterationType into string.
std::string	stringify (ElementType t)
	Convert ElementType into string.
std::string	stringify (libMesh::ElemType t)
	Convert the libmesh ElemType into string.
template<typename T , typename U >
std::string	stringify (const std::pair< T, U > &p, const std::string &delim=":")
	Add pair stringify to support maps.
template<typename... Args>
std::string	stringify (const std::tuple< Args... > &t, const std::string &delim=":")
	Add tuple stringify.
template<template< typename... > class T, typename... U>
std::string	stringify (const T< U... > &c, const std::string &delim=", ", const std::string &elem_encl="", bool enclose_list_in_curly_braces=false)
	Convert a container to a string with elements separated by delimiter of user's choice.
std::string	stringifyExact (Real)
	Stringify Reals with enough precision to guarantee lossless Real -> string -> Real roundtrips.
void	elementsIntersectedByPlane (const libMesh::Point &p0, const libMesh::Point &normal, const libMesh::MeshBase &mesh, std::vector< const libMesh::Elem * > &intersected_elems)
	Find all of the elements intersected by a plane.
void	elementsIntersectedByPlane (const libMesh::Point &p0, const libMesh::Point &p1, const libMesh::Point &p2, const libMesh::MeshBase &mesh, std::vector< const libMesh::Elem * > &intersected_elems)
	Find all of the elements intersected by a plane.
template<class Iterator >
_enumerate_range< Iterator >	enumerate (Iterator first, Iterator last, typename std::iterator_traits< Iterator >::difference_type initial)
	Enumerate function for iterating over a range and obtaining both a reference to the underlying type and an index simultaneously.
template<class Container >
_enumerate_range< typename Container::iterator >	enumerate (Container &content)
template<class Container >
_enumerate_range< typename Container::const_iterator >	enumerate (const Container &content)
std::string	getExec ()
	Gets the full path to the running executable on Mac OS X and linux.
std::string	getExecutablePath ()
	Gets the directory the running executable is on Mac OS X and linux.
std::string	getExecutableName ()
	Gets the name of the running executable on Mac OS X and linux.
template<class RandomAccessIterator >
void	initialize_indirect_sort (RandomAccessIterator beg, RandomAccessIterator end, std::vector< size_t > &b)
template<class RandomAccessIterator >
void	indirectSort (RandomAccessIterator beg, RandomAccessIterator end, std::vector< size_t > &b)
template<class RandomAccessIterator , class UserComparisonFunctor >
void	indirectSort (RandomAccessIterator beg, RandomAccessIterator end, std::vector< size_t > &b, UserComparisonFunctor user_comp)
template<typename T >
void	applyIndices (T &container, const std::vector< size_t > &indices)
	Uses indices created by the indirectSort function to sort the given container (which must support random access, resizing, and std::swap.
template<typename T , typename C >
std::map< T, C >	createMapFromVectors (const std::vector< T > &keys, const std::vector< C > &values)
	Create a map from two vectors.
template<typename T >
std::map< T, MooseEnum >	createMapFromVectorAndMultiMooseEnum (const std::vector< T > &keys, const MultiMooseEnum &values)
	Create a map from a vector of keys and MultiMooseEnum acting as a vector.
void	hash_combine (std::size_t &)
	Used for hash function specialization for Attribute objects.
template<typename T , typename... Rest>
void	hash_combine (std::size_t &seed, const T &v, Rest &&... rest)
	Used to combine an existing hash value with the hash of one or more other values (v and rest).
template<typename T , typename... Rest>
void	hash_combine (std::size_t &seed, const std::vector< T > &v, Rest &&... rest)
	Used for hash function specialization for Attribute objects.
template<typename T , typename... Rest>
void	hash_combine (std::size_t &seed, const std::set< T > &v, Rest &&... rest)
	Used for hash function specialization for Attribute objects.
template<typename T >
T	fe_lagrange_1D_shape (const Order order, const unsigned int i, const T &xi)
template<typename T >
T	fe_lagrange_1D_shape_deriv (const Order order, const unsigned int i, const T &xi)
template<typename T , template< typename > class VectorType>
T	fe_lagrange_2D_shape (const libMesh::ElemType type, const Order order, const unsigned int i, const VectorType< T > &p)
template<typename T , template< typename > class VectorType>
T	fe_lagrange_2D_shape_deriv (const libMesh::ElemType type, const Order order, const unsigned int i, const unsigned int j, const VectorType< T > &p)
std::string	stringify (const Moose::RelationshipManagerType &t)
std::string	stringify (const Moose::TimeIntegratorType &t)
template<class C >
auto	makeSpan (C &container, std::size_t offset, std::size_t n)
	Helper function for creating a span from a given container.
template<std::size_t N>
void	derivInsert (NumberArray< N, Real > &derivs, dof_id_type index, Real value)
void	elementsIntersectedByLine (const Point &p0, const Point &p1, const MeshBase &mesh, const libMesh::PointLocatorBase &point_locator, std::vector< Elem * > &intersected_elems, std::vector< LineSegment > &segments)
	Find all of the elements intersected by a line.
	SERIAL_ACCESS_SCALAR (Real)
	SERIAL_ACCESS_SCALAR (ADReal)
	SERIAL_ACCESS_CONST_SIZE (libMesh::VectorValue, &obj(0u), Moose::dim)
	SERIAL_ACCESS_CONST_SIZE (RankTwoTensorTempl, &obj(0u, 0u), RankTwoTensorTempl< T >::N2)
	SERIAL_ACCESS_CONST_SIZE (RankFourTensorTempl, &obj(0u, 0u, 0u, 0u), RankFourTensorTempl< T >::N4)
	SERIAL_ACCESS_DYNAMIC_SIZE (DenseVector, &obj(0u), obj.size())
template<typename T >
SerialAccessRange< T >	serialAccess (T &obj)
template<template< typename, int > class L, int I, typename T , typename... Ts, typename... As>
void	typeLoopInternal (TypeList< T, Ts... >, As... args)
	Type loop.
template<template< typename, int > class L, typename... Ts, typename... As>
void	typeLoop (TypeList< Ts... >, As... args)
	Type loop.
template<typename T >
void	initDofIndices (T &data, const Elem &elem)
void	associateSyntaxInner (Syntax &syntax, ActionFactory &action_factory)
void	findContactPoint (PenetrationInfo &p_info, FEBase *fe_elem, FEBase *fe_side, FEType &, const libMesh::Point &secondary_point, bool start_with_centroid, const Real tangential_tolerance, bool &contact_point_on_side, bool &search_succeeded)
	Finds the closest point (called the contact point) on the primary_elem on side "side" to the secondary_point.
void	restrictPointToFace (libMesh::Point &p, const Elem *side, std::vector< const Node * > &off_edge_nodes)
bool	isSectionActive (const hit::Node &node)
std::vector< std::string >	findSimilar (const std::string &param, const std::vector< std::string > &options)
void	compute_linear_system (libMesh::EquationSystems &es, const std::string &system_name)
void	compute_jacobian (const NumericVector< Number > &soln, SparseMatrix< Number > &jacobian, NonlinearImplicitSystem &sys)
void	compute_bounds (NumericVector< Number > &lower, NumericVector< Number > &upper, NonlinearImplicitSystem &sys)
void	compute_nullspace (std::vector< NumericVector< Number > * > &sp, NonlinearImplicitSystem &sys)
void	compute_transpose_nullspace (std::vector< NumericVector< Number > * > &sp, NonlinearImplicitSystem &sys)
void	compute_nearnullspace (std::vector< NumericVector< Number > * > &sp, NonlinearImplicitSystem &sys)
void	compute_postcheck (const NumericVector< Number > &old_soln, NumericVector< Number > &search_direction, NumericVector< Number > &new_soln, bool &changed_search_direction, bool &changed_new_soln, NonlinearImplicitSystem &sys)
void	initCoordinateSystemType ()
void	initSolveType ()
void	initEigenSolveType ()
void	initEigenProlemType ()
void	initWhichEigenPairs ()
void	initLineSearchType ()
void	initTimeIntegratorsType ()
void	initMffdType ()
void	initRMType ()
template<>
QuadratureType	stringToEnum< QuadratureType > (const std::string &s)
template<>
Order	stringToEnum< Order > (const std::string &s)
template<>
CoordinateSystemType	stringToEnum< CoordinateSystemType > (const std::string &s)
template<>
SolveType	stringToEnum< SolveType > (const std::string &s)
template<>
EigenSolveType	stringToEnum< EigenSolveType > (const std::string &s)
template<>
EigenProblemType	stringToEnum< EigenProblemType > (const std::string &s)
template<>
WhichEigenPairs	stringToEnum< WhichEigenPairs > (const std::string &s)
template<>
LineSearchType	stringToEnum< LineSearchType > (const std::string &s)
template<>
TimeIntegratorType	stringToEnum< TimeIntegratorType > (const std::string &s)
template<>
MffdType	stringToEnum< MffdType > (const std::string &s)
template<>
RelationshipManagerType	stringToEnum< RelationshipManagerType > (const std::string &s)
Point	toPoint (const std::vector< Real > &pos)
void	findElementsIntersectedByPlane (const libMesh::Plane &plane, const MeshBase &mesh, std::vector< const Elem * > &intersected_elems)
void	elementsIntersectedByPlane (const Point &p0, const Point &normal, const MeshBase &mesh, std::vector< const Elem * > &intersected_elems)
void	elementsIntersectedByPlane (const Point &p0, const Point &p1, const Point &p2, const MeshBase &mesh, std::vector< const Elem * > &intersected_elems)
int	sideIntersectedByLine (const Elem *elem, std::vector< int > &not_side, const LineSegment &line_segment, Point &intersection_point)
	Figure out which (if any) side of an Elem is intersected by a line.
int	sideNeighborIsOn (const Elem *elem, const Elem *neighbor)
	Returns the side number for elem that neighbor is on.
void	recursivelyFindElementsIntersectedByLine (const LineSegment &line_segment, const Elem *current_elem, int incoming_side, const Point &incoming_point, std::vector< Elem * > &intersected_elems, std::vector< LineSegment > &segments)
	Recursively find all elements intersected by a line segment.
void	elementsIntersectedByLine (const Point &p0, const Point &p1, const MeshBase &, const PointLocatorBase &point_locator, std::vector< Elem * > &intersected_elems, std::vector< LineSegment > &segments)

Variables
static constexpr std::size_t	dim = LIBMESH_DIM
	This is the dimension of all vector and tensor datastructures used in MOOSE.
constexpr std::size_t	invalid_size_t = std::numeric_limits<std::size_t>::max()
	Value for invalid size_t indices.
volatile std::sig_atomic_t	interrupt_signal_number = 0
	Used by the signal handler to determine if we should write a checkpoint file out at any point during operation.
bool	show_multiple = false
	Set to false (the default) to display an error message only once for each error call code location (as opposed to every time the code is executed).
libMesh::PerfLog	perf_log
	Perflog to be used by applications.
bool	_trap_fpe
	Variable indicating whether we will enable FPE trapping for this run.
bool	_warnings_are_errors = false
	Variable to toggle any warning into an error (includes deprecated code warnings)
bool	_deprecated_is_error = false
	Variable to toggle only deprecated warnings as errors.
bool	_throw_on_error = false
	Variable to turn on exceptions during mooseError(), should only be used within MOOSE unit tests or when about to perform threaded operations because exception throwing in threaded regions is safe while aborting is inherently not when singletons are involved (e.g.
bool	_throw_on_warning = false
	Variable to turn on exceptions during mooseWarning(), should only be used in MOOSE unit tests.
ExecFlagEnum	execute_flags
	Storage for the registered execute flags.
constexpr std::size_t	constMaxQpsPerElem = 1000
	This is used for places where we initialize some qp-sized data structures that would end up being sized too small after the quadrature order gets bumped (dynamically in-sim).
template<class... Ts>
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 constexpr-based if conditions.
const processor_id_type	INVALID_PROCESSOR_ID = libMesh::DofObject::invalid_processor_id
const SubdomainID	ANY_BLOCK_ID = libMesh::Elem::invalid_subdomain_id - 1
const SubdomainID	INVALID_BLOCK_ID = libMesh::Elem::invalid_subdomain_id
const BoundaryID	ANY_BOUNDARY_ID = static_cast<BoundaryID>(-1)
const BoundaryID	INVALID_BOUNDARY_ID = libMesh::BoundaryInfo::invalid_id
const TagID	INVALID_TAG_ID = static_cast<TagID>(-1)
const TagTypeID	INVALID_TAG_TYPE_ID = static_cast<TagTypeID>(-1)
const std::set< SubdomainID >	EMPTY_BLOCK_IDS = {}
const std::set< BoundaryID >	EMPTY_BOUNDARY_IDS = {}
const TagName	SOLUTION_TAG = "SOLUTION"
const TagName	OLD_SOLUTION_TAG = "SOLUTION_STATE_1"
const TagName	OLDER_SOLUTION_TAG = "SOLUTION_STATE_2"
const TagName	PREVIOUS_NL_SOLUTION_TAG = "U_PREVIOUS_NL_NEWTON"
const TagName	PREVIOUS_MULTIAPP_FP_SOLUTION_TAG = "U_PREVIOUS_MULTIAPP_FP"
const TagName	PREVIOUS_MULTISYSTEM_FP_SOLUTION_TAG = "U_PREVIOUS_MULTISYSTEM_FP"
const TagName	SOLUTION_DOT_TAG = "u_dot_factor"
const TagName	SOLUTION_DOTDOT_TAG = "u_dotdot_factor"
static bool	_color_console = isatty(fileno(stdout))
std::map< std::string, CoordinateSystemType >	coordinate_system_type_to_enum
std::map< std::string, SolveType >	solve_type_to_enum
std::map< std::string, EigenSolveType >	eigen_solve_type_to_enum
std::map< std::string, EigenProblemType >	eigen_problem_type_to_enum
std::map< std::string, WhichEigenPairs >	which_eigen_pairs_to_enum
std::map< std::string, LineSearchType >	line_search_type_to_enum
std::map< std::string, TimeIntegratorType >	time_integrator_to_enum
std::map< std::string, MffdType >	mffd_type_to_enum
std::map< std::string, RelationshipManagerType >	rm_type_to_enum

Detailed Description

MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to address this in their environment if C++17 compatibility isn't found.

Typedef Documentation

Functor

template<typename T >

using Moose::Functor = typedef FunctorEnvelope<T>

Definition at line 33 of file MooseFunctorForward.h.

GenericType

template<typename T , bool is_ad>

using Moose::GenericType = typedef typename std::conditional<is_ad, typename ADType<T>::type, T>::type

Definition at line 694 of file MooseTypes.h.

RelationshipManagerInputParameterCallback

typedef std::function<void(const InputParameters &, InputParameters &)> Moose::RelationshipManagerInputParameterCallback

The type for the callback to set RelationshipManager parameters.

Definition at line 1043 of file MooseTypes.h.

Enumeration Type Documentation

AuxGroup

enum Moose::AuxGroup

Flag for AuxKernel related execution type.

Enumerator
PRE_IC
PRE_AUX
POST_AUX
ALL

Definition at line 757 of file MooseTypes.h.

{
  PRE_IC = 0,
  PRE_AUX = 1,
  POST_AUX = 2,
  ALL = 3
};

ComputeType

enum class Moose::ComputeType

strong

The type of nonlinear computation being performed.

Enumerator
Residual
Jacobian
ResidualAndJacobian

Definition at line 834 of file MooseTypes.h.

{
  Residual,
  Jacobian,
  ResidualAndJacobian
};

ConstraintFormulationType

enum Moose::ConstraintFormulationType

Type of constraint formulation.

Enumerator
Penalty
Kinematic

Definition at line 971 of file MooseTypes.h.

{
  Penalty,
  Kinematic
};

ConstraintJacobianType

enum Moose::ConstraintJacobianType

Enumerator
SecondarySecondary
SecondaryPrimary
PrimarySecondary
PrimaryPrimary
LowerLower
LowerSecondary
LowerPrimary
SecondaryLower
PrimaryLower

Definition at line 850 of file MooseTypes.h.

{
  SecondarySecondary = ElementElement,
  SecondaryPrimary = ElementNeighbor,
  PrimarySecondary = NeighborElement,
  PrimaryPrimary = NeighborNeighbor,
  LowerLower,
  LowerSecondary,
  LowerPrimary,
  SecondaryLower,
  PrimaryLower
};

ConstraintSideType

enum Moose::ConstraintSideType

Enumerator
SIDE_PRIMARY
SIDE_SECONDARY

Definition at line 791 of file MooseTypes.h.

{
  SIDE_PRIMARY,
  SIDE_SECONDARY
};

ConstraintType

enum Moose::ConstraintType

Enumerator
Secondary
Primary

Definition at line 811 of file MooseTypes.h.

{
  Secondary = Element,
  Primary = Neighbor
};

CoordinateSystemType

enum Moose::CoordinateSystemType : int

Enumerator
COORD_XYZ
COORD_RZ
COORD_RSPHERICAL

Definition at line 863 of file MooseTypes.h.

{
  COORD_XYZ = 0,
  COORD_RZ,
  COORD_RSPHERICAL
};

CouplingType

enum Moose::CouplingType

Enumerator
COUPLING_DIAG
COUPLING_FULL
COUPLING_CUSTOM

Definition at line 784 of file MooseTypes.h.

{
  COUPLING_DIAG,
  COUPLING_FULL,
  COUPLING_CUSTOM
};

DGJacobianType

enum Moose::DGJacobianType

Enumerator
ElementElement
ElementNeighbor
NeighborElement
NeighborNeighbor

Definition at line 803 of file MooseTypes.h.

{
  ElementElement,
  ElementNeighbor,
  NeighborElement,
  NeighborNeighbor
};

DGResidualType

enum Moose::DGResidualType

Enumerator
Element
Neighbor

Definition at line 797 of file MooseTypes.h.

{
  Element,
  Neighbor
};

EigenProblemType

enum Moose::EigenProblemType

Type of the eigen problem.

Enumerator
EPT_HERMITIAN	Hermitian.
EPT_NON_HERMITIAN	Non-Hermitian.
EPT_GEN_HERMITIAN	Generalized Hermitian.
EPT_GEN_INDEFINITE	Generalized Hermitian indefinite.
EPT_GEN_NON_HERMITIAN	Generalized Non-Hermitian.
EPT_POS_GEN_NON_HERMITIAN	Generalized Non-Hermitian with positive (semi-)definite B.
EPT_SLEPC_DEFAULT	use whatever SLPEC has by default

Definition at line 924 of file MooseTypes.h.

{
  EPT_HERMITIAN,             
  EPT_NON_HERMITIAN,         
  EPT_GEN_HERMITIAN,         
  EPT_GEN_INDEFINITE,        
  EPT_GEN_NON_HERMITIAN,     
  EPT_POS_GEN_NON_HERMITIAN, 
  EPT_SLEPC_DEFAULT          
};

EigenSolveType

enum Moose::EigenSolveType

Type of the eigen solve.

Enumerator
EST_POWER	Power / Inverse / RQI.
EST_ARNOLDI	Arnoldi.
EST_KRYLOVSCHUR	Krylov-Schur.
EST_JACOBI_DAVIDSON	Jacobi-Davidson.
EST_NONLINEAR_POWER	Nonlinear inverse power.
EST_NEWTON	Newton-based eigensolver with an assembled Jacobian matrix (fully coupled by default)
EST_PJFNK	Preconditioned Jacobian-free Newton Krylov.
EST_PJFNKMO	The same as PJFNK except that matrix-vector multiplication is employed to replace residual evaluation in linear solver.
EST_JFNK	Jacobian-free Newton Krylov.

Definition at line 908 of file MooseTypes.h.

{
  EST_POWER,           
  EST_ARNOLDI,         
  EST_KRYLOVSCHUR,     
  EST_JACOBI_DAVIDSON, 
  EST_NONLINEAR_POWER, 
  EST_NEWTON, 
  EST_PJFNK,   
  EST_PJFNKMO, 
  EST_JFNK     
};

ElementType

enum class Moose::ElementType : unsigned int

strong

Enumerator
Element
Neighbor
Lower

Definition at line 817 of file MooseTypes.h.

{
  Element = DGResidualType::Element,
  Neighbor = DGResidualType::Neighbor,
  Lower = DGResidualType::Neighbor + 1
};

FEBackend

enum class Moose::FEBackend

strong

Enumerator
LibMesh
MFEM

Definition at line 1318 of file MooseTypes.h.

{
  LibMesh
#ifdef MOOSE_MFEM_ENABLED
  ,
  MFEM
#endif
};

FunctorEvaluationKind

enum class Moose::FunctorEvaluationKind

strong

An enumeration of possible functor evaluation kinds.

The available options are value, gradient, time derivative (dot), and gradient of time derivative (gradDot)

Enumerator
Value
Gradient
Dot
GradDot

Definition at line 36 of file MooseFunctor.h.

{
  Value,
  Gradient,
  Dot,
  GradDot
};

GeometryType

enum Moose::GeometryType

Enumerator
Volume
Face

Definition at line 282 of file MooseTypes.h.

{
  Volume,
  Face
};

LineSearchType

enum Moose::LineSearchType

Type of the line search.

Enumerator
LS_INVALID	means not set
LS_DEFAULT
LS_NONE
LS_BASIC
LS_SHELL
LS_CONTACT
LS_PROJECT
LS_L2
LS_BT
LS_CP

Definition at line 979 of file MooseTypes.h.

{
  LS_INVALID, 
  LS_DEFAULT,
  LS_NONE,
  LS_BASIC,
  LS_SHELL,
  LS_CONTACT,
  LS_PROJECT,
  LS_L2,
  LS_BT,
  LS_CP
};

MaterialDataType

enum Moose::MaterialDataType

MaterialData types.

See also

FEProblemBase, MaterialPropertyInterface

Enumerator
BLOCK_MATERIAL_DATA
BOUNDARY_MATERIAL_DATA
FACE_MATERIAL_DATA
NEIGHBOR_MATERIAL_DATA
INTERFACE_MATERIAL_DATA

Definition at line 745 of file MooseTypes.h.

{
  BLOCK_MATERIAL_DATA,
  BOUNDARY_MATERIAL_DATA,
  FACE_MATERIAL_DATA,
  NEIGHBOR_MATERIAL_DATA,
  INTERFACE_MATERIAL_DATA
};

MffdType

enum Moose::MffdType

Type of the matrix-free finite-differencing parameter.

Enumerator
MFFD_INVALID	means not set
MFFD_WP
MFFD_DS

Definition at line 996 of file MooseTypes.h.

{
  MFFD_INVALID, 
  MFFD_WP,
  MFFD_DS
};

MooseKSPNormType

enum Moose::MooseKSPNormType

Norm type for converge test.

Enumerator
KSPN_NONE
KSPN_PRECONDITIONED
KSPN_UNPRECONDITIONED
KSPN_NATURAL
KSPN_DEFAULT	Use whatever we have in PETSc.

Definition at line 884 of file MooseTypes.h.

{
  KSPN_NONE,
  KSPN_PRECONDITIONED,
  KSPN_UNPRECONDITIONED,
  KSPN_NATURAL,
  KSPN_DEFAULT 
};

MortarType

enum class Moose::MortarType : unsigned int

strong

Enumerator
Secondary
Primary
Lower

Definition at line 824 of file MooseTypes.h.

{
  Secondary = static_cast<unsigned int>(Moose::ElementType::Element),
  Primary = static_cast<unsigned int>(Moose::ElementType::Neighbor),
  Lower = static_cast<unsigned int>(Moose::ElementType::Lower)
};

PatchUpdateType

enum Moose::PatchUpdateType

Type of patch update strategy for modeling node-face constraints or contact.

Enumerator
Never
Always
Auto
Iteration

Definition at line 1006 of file MooseTypes.h.

{
  Never,
  Always,
  Auto,
  Iteration
};

PCSideType

enum Moose::PCSideType

Preconditioning side.

Enumerator
PCS_LEFT
PCS_RIGHT
PCS_SYMMETRIC
PCS_DEFAULT	Use whatever we have in PETSc.

Definition at line 873 of file MooseTypes.h.

{
  PCS_LEFT,
  PCS_RIGHT,
  PCS_SYMMETRIC,
  PCS_DEFAULT 
};

RelationshipManagerType

enum class Moose::RelationshipManagerType : unsigned char

strong

Main types of Relationship Managers.

Enumerator
DEFAULT
GEOMETRIC
ALGEBRAIC
COUPLING

Definition at line 1017 of file MooseTypes.h.

{
  DEFAULT = 0,
  GEOMETRIC = 1 << 0,
  ALGEBRAIC = 1 << 1,
  COUPLING = 1 << 2
};

RESTARTABLE_FILTER

enum class Moose::RESTARTABLE_FILTER : unsigned char

strong

The filter type applied to a particular piece of "restartable" data.

These filters will be applied during deserialization to include or exclude data as appropriate.

Enumerator
RECOVERABLE

Definition at line 845 of file MooseTypes.h.

{
  RECOVERABLE
};

RMSystemType

enum Moose::RMSystemType

Enumerator
NONLINEAR
AUXILIARY
NONE

Definition at line 1025 of file MooseTypes.h.

{
  NONLINEAR,
  AUXILIARY,
  NONE
};

SolutionIterationType

enum class Moose::SolutionIterationType : unsigned short

strong

Enumerator
Time
Nonlinear
MultiAppFixedPoint
MultiSystemFixedPoint
Count

Definition at line 269 of file MooseTypes.h.

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

SolutionState

enum Moose::SolutionState : int

Enumerator
Current
Old
Older
PreviousNL

Definition at line 261 of file MooseTypes.h.

{
  Current = 0,
  Old = 1,
  Older = 2,
  PreviousNL = -1
};

SolveType

enum Moose::SolveType

Type of the solve.

Enumerator
ST_PJFNK	Preconditioned Jacobian-Free Newton Krylov.
ST_JFNK	Jacobian-Free Newton Krylov.
ST_NEWTON	Full Newton Solve.
ST_FD	Use finite differences to compute Jacobian.
ST_LINEAR	Solving a linear problem.

Definition at line 896 of file MooseTypes.h.

{
  ST_PJFNK,  
  ST_JFNK,   
  ST_NEWTON, 
  ST_FD,     
  ST_LINEAR  
};

TimeIntegratorType

enum Moose::TimeIntegratorType

Time integrators.

Enumerator
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

Definition at line 956 of file MooseTypes.h.

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

VarFieldType

enum Moose::VarFieldType

Enumerator
VAR_FIELD_STANDARD
VAR_FIELD_SCALAR
VAR_FIELD_VECTOR
VAR_FIELD_ARRAY
VAR_FIELD_ANY

Definition at line 775 of file MooseTypes.h.

{
  VAR_FIELD_STANDARD,
  VAR_FIELD_SCALAR,
  VAR_FIELD_VECTOR,
  VAR_FIELD_ARRAY,
  VAR_FIELD_ANY
};

VarKindType

enum Moose::VarKindType

Framework-wide stuff.

Enumerator
VAR_SOLVER
VAR_AUXILIARY
VAR_ANY

Definition at line 768 of file MooseTypes.h.

{
  VAR_SOLVER,
  VAR_AUXILIARY,
  VAR_ANY
};

VectorTagType

enum Moose::VectorTagType

Enumerator
VECTOR_TAG_RESIDUAL
VECTOR_TAG_SOLUTION
VECTOR_TAG_ANY

Definition at line 1032 of file MooseTypes.h.

{
  VECTOR_TAG_RESIDUAL = 0,
  VECTOR_TAG_SOLUTION = 1,
  VECTOR_TAG_ANY = 2
};

WhichEigenPairs

enum Moose::WhichEigenPairs

Which eigen pairs.

Enumerator
WEP_LARGEST_MAGNITUDE	largest magnitude
WEP_SMALLEST_MAGNITUDE	smallest magnitude
WEP_LARGEST_REAL	largest real
WEP_SMALLEST_REAL	smallest real
WEP_LARGEST_IMAGINARY	largest imaginary
WEP_SMALLEST_IMAGINARY	smallest imaginary
WEP_TARGET_MAGNITUDE	target magnitude
WEP_TARGET_REAL	target real
WEP_TARGET_IMAGINARY	target imaginary
WEP_ALL_EIGENVALUES	all eigenvalues
WEP_SLEPC_DEFAULT	use whatever we have in SLEPC

Definition at line 938 of file MooseTypes.h.

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

Function Documentation

addActionTypes()

void Moose::addActionTypes

(

Syntax &

syntax

)

The (optional) last param here indicates whether the task should trigger an Action auto-build. If a task is marked as "true". Then MOOSE will attempt to build the associated Action if one is not supplied by some other means (usually through the input file or custom Action). Only Actions that do not have required parameters and have defaults for all optional parameters can be built automatically (See ActionWarehouse.C).

Note: Many of the actions in the "Minimal Problem" section are marked as false. However, we can generally force creation of these "Action"s as needed by registering them to syntax that we expect to see even if those "Action"s don't normally pick up parameters from the input file.

Additional Actions

The following is the default set of action dependencies for a basic MOOSE problem. The formatting of this string is important. Each line represents a set of dependencies that depend on the previous line. Items on the same line have equal weight and can be executed in any order.

Additional dependencies can be inserted later inside of user applications with calls to ActionWarehouse::addDependency("task", "pre_req")

The (optional) last param here indicates whether the task should trigger an Action auto-build. If a task is marked as "true". Then MOOSE will attempt to build the associated Action if one is not supplied by some other means (usually through the input file or custom Action). Only Actions that do not have required parameters and have defaults for all optional parameters can be built automatically (See ActionWarehouse.C).

Note: Many of the actions in the "Minimal Problem" section are marked as false. However, we can generally force creation of these "Action"s as needed by registering them to syntax that we expect to see even if those "Action"s don't normally pick up parameters from the input file.

Additional Actions

The following is the default set of action dependencies for a basic MOOSE problem. The formatting of this string is important. Each line represents a set of dependencies that depend on the previous line. Items on the same line have equal weight and can be executed in any order.

Additional dependencies can be inserted later inside of user applications with calls to ActionWarehouse::addDependency("task", "pre_req")

Definition at line 116 of file Moose.C.

         {2006},
  url={http://dx.doi.org/10.1007/s00366-006-0049-3}
})");
 
#ifdef MOOSE_MFEM_ENABLED
  // Like libMesh, the MFEM citation is emitted by MooseApp::requestCitations() only when the run
  // actually uses the MFEM backend.
  Registry::addAppCitation("MFEM",
                           "mfem-2024",
                           R"(@article{mfem-2024,
  title = {High-Performance Finite Elements with {MFEM}},
  author = {J. Andrej and N. Atallah and J.-P. B{\"a}cker and J.-S. Camier and D. Copeland and V. Dobrev and Y. Dudouit and T. Duswald and B. Keith and D. Kim and T. Kolev and B. Lazarov and K. Mittal and W. Pazner and S. Petrides and S. Shiraiwa and M. Stowell and V. Tomov},
  journal = {The International Journal of High Performance Computing Applications},
  volume = {38},
  number = {5},
  pages = {447--467},
  year = {2024},
  publisher = {SAGE Publications Sage UK: London, England},
})");
#endif
}
 
void
registerObjects(Factory & factory, const std::set<std::string> & obj_labels)
{
  Registry::registerObjectsTo(factory, obj_labels);
}
 
void
addActionTypes(Syntax & syntax)
{
  // clang-format off
  /**************************/
  /**** Register Actions ****/
  /**************************/
  registerMooseObjectTask("create_problem",               Problem,                   false);
  registerMooseObjectTask("setup_executioner",            Executioner,               false);
  registerMooseObjectTask("read_executor",                Executor,                  false);
  registerTask("add_executor", true);
 
  // TODO Organize these somewhere
  registerTask("init_physics", false);
  registerTask("init_component_physics", false);
  registerTask("meta_action_component", false);
  registerTask("setup_component", false);
  // 'list_component' is used to retrieve ActionComponents for the syntax JSON
  registerTask("list_component", false);
 
  // This task does not construct an object, but it needs all of the parameters that
  // would normally be used to construct an object.
  registerMooseObjectTask("determine_system_type",            Executioner,               true);
 
  registerMooseObjectTask("setup_mesh",                       MooseMesh,                 false);
  registerMooseObjectTask("set_mesh_base",                    MooseMesh,                 false);
  registerMooseObjectTask("init_mesh",                        MooseMesh,                 false);
  registerMooseObjectTask("add_mesh_generator",               MeshGenerator,             false);
  registerTask("create_added_mesh_generators", true);
  registerMooseObjectTask("append_mesh_generator",            MeshGenerator,             false);
 
  registerMooseObjectTask("add_kernel",                       Kernel,                    false);
  appendMooseObjectTask  ("add_kernel",                       EigenKernel);
  appendMooseObjectTask  ("add_kernel",                       VectorKernel);
  appendMooseObjectTask  ("add_kernel",                       ArrayKernel);
  appendMooseObjectTask  ("add_kernel",                       ADArrayKernel);
 
  registerMooseObjectTask("add_variable",                     MooseVariableBase,         false);
  registerMooseObjectTask("add_aux_variable",                 MooseVariableBase,         false);
  registerMooseObjectTask("add_elemental_field_variable",     MooseVariableBase,         false);
  registerMooseObjectTask("add_variables_physics",            MooseVariableBase,         false);
 
  registerMooseObjectTask("add_nodal_kernel",                 NodalKernel,               false);
 
  registerMooseObjectTask("add_functor_material",             FunctorMaterial,           false);
  registerMooseObjectTask("add_material",                     MaterialBase,              false);
  appendDeprecatedMooseObjectTask("add_material",             FunctorMaterial);
  registerMooseObjectTask("add_materials_physics",            FunctorMaterial,           false);
  appendMooseObjectTask  ("add_materials_physics",            MaterialBase);
 
  registerMooseObjectTask("add_bc",                           BoundaryCondition,         false);
 
  registerMooseObjectTask("add_function",                     Function,                  false);
 
  registerMooseObjectTask("add_distribution",                 Distribution,              false);
  registerMooseObjectTask("add_sampler",                      Sampler,                   false);
 
  registerMooseObjectTask("add_aux_kernel",                   AuxKernel,                 false);
  appendMooseObjectTask  ("add_aux_kernel",                   VectorAuxKernel);
  appendMooseObjectTask  ("add_aux_kernel",                   ArrayAuxKernel);
 
  registerMooseObjectTask("add_bound",                        Bounds,                    false);
 
  registerMooseObjectTask("add_scalar_kernel",                ScalarKernel,              false);
  registerMooseObjectTask("add_aux_scalar_kernel",            AuxScalarKernel,           false);
  registerMooseObjectTask("add_dirac_kernel",                 DiracKernel,               false);
  appendMooseObjectTask  ("add_dirac_kernel",                 VectorDiracKernel);
  registerMooseObjectTask("add_dg_kernel",                    DGKernel,                  false);
  registerMooseObjectTask("add_fv_kernel",                    FVKernel,                  false);
  registerMooseObjectTask("add_gradient_method",              FVGradientMethod,          false);
  registerMooseObjectTask("add_interpolation_method",         FVInterpolationMethod,     false);
  registerMooseObjectTask("add_interpolation_method_physics", FVInterpolationMethod,     false);
  registerMooseObjectTask("add_linear_fv_kernel",             LinearFVKernel,            false);
  registerMooseObjectTask("add_fv_bc",                        FVBoundaryCondition,       false);
  registerMooseObjectTask("add_linear_fv_bc",                 LinearFVBoundaryCondition, false);
  registerMooseObjectTask("add_fv_ik",                        FVInterfaceKernel,         false);
  registerMooseObjectTask("add_interface_kernel",             InterfaceKernel,           false);
  appendMooseObjectTask  ("add_interface_kernel",             VectorInterfaceKernel);
  registerMooseObjectTask("add_constraint",                   Constraint,                false);
  registerMooseObjectTask("add_hybridized_kernel",            HDGKernel,                 false);
  registerMooseObjectTask("add_hybridized_integrated_bc",     HDGIntegratedBC,           false);
 
  registerMooseObjectTask("add_ic",                           InitialCondition,          false);
  appendMooseObjectTask  ("add_ic",                           ScalarInitialCondition);
  registerMooseObjectTask("add_fv_ic",                        FVInitialCondition,        false);
  registerMooseObjectTask("add_ics_physics",                  InitialCondition,          false);
  appendMooseObjectTask  ("add_ics_physics",                  FVInitialCondition);
  appendMooseObjectTask  ("add_ics_physics",                  ScalarInitialCondition);
 
  registerMooseObjectTask("add_damper",                       Damper,                    false);
  registerMooseObjectTask("setup_predictor",                  Predictor,                 false);
  registerMooseObjectTask("add_time_steppers",                TimeStepper,               false);
  registerMooseObjectTask("add_time_stepper",                 TimeStepper,               false);
  registerTask           ("compose_time_stepper",                                    true);
  registerMooseObjectTask("setup_time_integrators",           TimeIntegrator,            false);
  registerMooseObjectTask("setup_time_integrator",            TimeIntegrator,            false);
  registerMooseObjectTask("add_convergence",                  Convergence,               false);
 
  registerMooseObjectTask("add_preconditioning",              MoosePreconditioner,       false);
  registerMooseObjectTask("add_field_split",                  Split,                     false);
 
  registerMooseObjectTask("add_mesh_division",                MeshDivision,              false);
  registerMooseObjectTask("add_user_object",                  UserObject,                false);
  appendMooseObjectTask  ("add_user_object",                  Postprocessor);
 
  appendDeprecatedMooseObjectTask("add_user_object",          Corrector);
  registerMooseObjectTask("add_corrector",                    Corrector,                 false);
  appendDeprecatedMooseObjectTask("add_user_object",          MeshModifier);
  registerMooseObjectTask("add_mesh_modifier",                MeshModifier,              false);
 
  registerMooseObjectTask("add_postprocessor",                Postprocessor,             false);
  registerMooseObjectTask("add_vector_postprocessor",         VectorPostprocessor,       false);
  registerMooseObjectTask("add_reporter",                     Reporter,                  false);
 
  registerMooseObjectTask("add_positions",                    Positions,                 false);
  registerMooseObjectTask("add_times",                        Times,                     false);
 
  registerMooseObjectTask("add_indicator",                    Indicator,                 false);
  registerMooseObjectTask("add_marker",                       Marker,                    false);
 
  registerMooseObjectTask("add_multi_app",                    MultiApp,                  false);
  registerMooseObjectTask("add_transfer",                     Transfer,                  false);
 
  registerMooseObjectTask("add_output",                       Output,                    false);
 
  registerMooseObjectTask("add_control",                      Control,                   false);
  registerMooseObjectTask("add_chain_control",                ChainControl,              false);
  registerMooseObjectTask("add_partitioner",                  MoosePartitioner,          false);
 
  // clang-format on
 
  registerTask("dynamic_object_registration", false);
  registerTask("common_output", true);
  registerTask("setup_recover_file_base", true);
  registerTask("recover_meta_data", true);
 
  registerTask("add_bounds_vectors", false);
  registerTask("add_periodic_bc", false);
  registerTask("add_aux_variable", false);
  registerTask("add_external_aux_variables", true);
  registerTask("add_variable", false);
  registerTask("add_mortar_variable", false);
 
  registerTask("execute_mesh_generators", true);
  registerTask("uniform_refine_mesh", false);
  registerTask("prepare_mesh", false);
  registerTask("delete_remote_elements_after_late_geometric_ghosting", false);
  registerTask("setup_mesh_complete", true); // calls prepare
  registerTask("post_mesh_prepared", false);
  registerTask("add_geometric_rm", false);
  registerTask("attach_geometric_rm", true);
  registerTask("attach_geometric_rm_final", true);
 
  registerTask("init_displaced_problem", false);
 
  registerTask("add_algebraic_rm", false);
  registerTask("attach_algebraic_rm", true);
  registerTask("add_coupling_rm", false);
  registerTask("attach_coupling_rm", true);
  registerTask("init_problem", true);
  registerTask("check_copy_nodal_vars", true);
  registerTask("copy_nodal_vars", true);
  registerTask("copy_nodal_aux_vars", true);
  registerTask("copy_vars_physics", false);
  registerTask("setup_postprocessor_data", false);
  registerTask("setup_time_steppers", true);
 
  registerTask("setup_dampers", true);
  registerTask("check_integrity", true);
  registerTask("resolve_optional_materials", true);
  registerTask("check_integrity_early", true);
  registerTask("check_integrity_early_physics", false);
  registerTask("setup_quadrature", true);
  registerTask("create_tagged_matrices", true);
 
  registerTask("mesh_modifiers", false);
 
  registerTask("no_action", false); // Used for Empty Action placeholders
  registerTask("set_global_params", false);
  registerTask("setup_adaptivity", false);
  registerTask("meta_action", false);
  registerTask("setup_residual_debug", false);
  registerTask("setup_oversampling", false);
  registerTask("deprecated_block", false);
  registerTask("set_adaptivity_options", false);
  registerTask("add_mortar_interface", false);
  registerTask("coupling_functor_check", true);
  registerTask("add_master_action_material", false);
  registerTask("setup_projected_properties", false);
  registerTask("create_application_block", false);
 
  // Dummy Actions (useful for sync points in the dependencies)
  registerTask("setup_function_complete", false);
  registerTask("setup_variable_complete", false);
  registerTask("setup_executioner_complete", false);
  registerTask("ready_to_init", true);
 
  // Output related actions
  registerTask("add_output_aux_variables", true);
  registerTask("check_output", true);
  registerTask("declare_late_reporters", true);
 
  registerTask("create_problem_default", true);
  registerTask("create_problem_custom", false);
  registerTask("create_problem_complete", false);
 
  registerTask("add_default_nonlinear_convergence", true);
  registerTask("add_default_multiapp_fixed_point_convergence", true);
  registerTask("add_default_steady_state_convergence", true);
 
  registerTask("chain_control_setup", true);
  registerTask("start_webservercontrol", true);
 
  // Action for setting up the signal-based checkpoint
  registerTask("auto_checkpoint_action", true);
  /**************************/
  /****** Dependencies ******/
  /**************************/
  // clang-format off
  syntax.addDependencySets("(meta_action)"
                           "(meta_action_component)"
                           "(dynamic_object_registration)"
                           "(common_output)"
                           "(set_global_params)"
                           "(setup_recover_file_base)"
                           "(check_copy_nodal_vars)"
                           "(setup_mesh)"
                           "(add_geometric_rm)"
                           "(add_partitioner)"
                           "(add_mesh_generator)"
                           "(create_added_mesh_generators)"
                           "(append_mesh_generator)"
                           "(execute_mesh_generators)"
                           "(recover_meta_data)"
                           "(set_mesh_base)"
                           "(attach_geometric_rm)"
                           "(init_mesh)"
                           "(prepare_mesh)"
                           "(add_mortar_interface)"
                           "(uniform_refine_mesh)"
                           "(setup_mesh_complete)"
                           "(post_mesh_prepared)"
                           "(determine_system_type)"
                           "(create_problem)"
                           "(create_problem_custom)"
                           "(create_problem_default)"
                           "(create_problem_complete)"
                           "(init_displaced_problem)" // Problem must be init-ed before we start adding functors
                           "(add_function)"  // Functions can depend on scalar variables & PPs, but this dependence can be
                                             // added on initialSetup() rather than construction
                           "(init_component_physics)" // components must add their blocks to physics before init_physics
                           "(init_physics)"
                           "(setup_postprocessor_data)"
                           "(setup_time_integrator, setup_time_integrators)"
                           "(setup_executioner)"
                           "(setup_executioner_complete)"
                           "(setup_component)"  // no particular reason for that placement
                           "(read_executor)"
                           "(add_executor)"
                           "(check_integrity_early)"
                           "(setup_predictor)"
                           "(add_aux_variable, add_variable, add_elemental_field_variable,"
                           " add_external_aux_variables)"
                           "(add_variables_physics)" // physics can skip adding variables if they already exist
                           "(add_mortar_variable)"
                           "(setup_variable_complete)"
                           "(check_integrity_early_physics)"  // checks that systems and variables are consistent
                           "(setup_quadrature)"
                           "(add_convergence)"
                           "(add_default_nonlinear_convergence,"
                           " add_default_multiapp_fixed_point_convergence,"
                           " add_default_steady_state_convergence)"
                           "(add_positions)"
                           "(add_periodic_bc)"
                           "(add_gradient_method)"
                           "(add_user_object, add_corrector, add_mesh_modifier)"
                           "(add_field_split)" // split objects required before field split preconditioner itself
                           "(add_preconditioning)" // preconditioner may introduce objects such as static condensation which influence the underlying types of tagged matrices
                           "(create_tagged_matrices)"
                           "(add_distribution)"
                           "(add_sampler)"
                           "(setup_function_complete)"
                           "(setup_adaptivity)"
                           "(set_adaptivity_options)"
                           "(add_ic, add_fv_ic)"
                           "(add_ics_physics)" // physics can skip adding initial conditions if they already exist
                           "(add_constraint)"
                           "(add_times)"
                           "(add_time_stepper, add_time_steppers)"
                           "(compose_time_stepper)"
                           "(setup_time_steppers)"
                           "(ready_to_init)"
                           "(setup_dampers)"
                           "(setup_residual_debug)"
                           "(add_bounds_vectors)"
                           "(add_mesh_division)"  // NearestPositionsDivision uses a Positions
                           "(add_multi_app)"
                           "(add_transfer)"
                           "(copy_nodal_vars, copy_nodal_aux_vars, copy_vars_physics)"
                           "(add_material)"
                           "(add_master_action_material)"
                           "(add_functor_material)"
                           "(add_materials_physics)"
                           "(setup_projected_properties)"
                           "(add_output_aux_variables)"
                           "(add_output)"
                           "(auto_checkpoint_action)"
                           "(add_postprocessor)"
                           "(add_vector_postprocessor)" // MaterialVectorPostprocessor requires this
                                                        // to be after material objects are created.
                           "(add_reporter)"
                           "(declare_late_reporters)"
                           "(add_aux_kernel, add_bc, add_damper, add_dirac_kernel, add_kernel,"
                           " add_nodal_kernel, add_dg_kernel, add_fv_kernel, add_interpolation_method,"
                           " add_interpolation_method_physics, add_linear_fv_kernel,"
                           " add_fv_bc, add_linear_fv_bc, add_fv_ik, add_interface_kernel,"
                           " add_scalar_kernel, add_aux_scalar_kernel, add_indicator, add_marker,"
                           " add_bound, add_hybridized_kernel, add_hybridized_integrated_bc)"
                           "(resolve_optional_materials)"
                           "(add_algebraic_rm)"
                           "(add_coupling_rm)"
                           "(attach_geometric_rm_final)"
                           "(attach_algebraic_rm)"
                           "(attach_coupling_rm)"
                           "(coupling_functor_check)"
                           "(delete_remote_elements_after_late_geometric_ghosting)"
                           "(init_problem)"
                           "(add_control, add_chain_control)"
                           "(chain_control_setup)"
                           "(start_webservercontrol)"
                           "(check_output)"
                           "(check_integrity)"
                           "(create_application_block)");
  // clang-format on
 
#ifdef MOOSE_MFEM_ENABLED
  registerTask("add_mfem_problem_operator", true);
  addTaskDependency("add_variable", "add_mfem_problem_operator");
  addTaskDependency("add_aux_variable", "add_mfem_problem_operator");
  addTaskDependency("add_elemental_field_variable", "add_mfem_problem_operator");
  addTaskDependency("add_bc", "add_mfem_problem_operator");
  addTaskDependency("add_kernel", "add_mfem_problem_operator");
 
  // add problem composers (and operators)
  registerMooseObjectTask("add_mfem_problem_composer", MFEMProblemComposer, false);
  addTaskDependency("add_mfem_problem_operator", "add_mfem_problem_composer");
  addTaskDependency("setup_executioner", "add_mfem_problem_composer");
 
  // add SubMeshes
  registerMooseObjectTask("add_mfem_submeshes", MFEMSubMesh, false);
  addTaskDependency("add_mfem_submeshes", "create_problem_complete");
 
  // add SubMesh transfers
  appendMooseObjectTask("add_transfer", MFEMSubMeshTransfer);
 
  // add FESpaces
  registerMooseObjectTask("add_mfem_fespaces", MFEMFESpace, false);
  appendMooseObjectTask("add_mfem_fespaces", MFEMFECollection);
  addTaskDependency("add_mfem_fespaces", "add_mfem_submeshes");
 
  // add FESpace hierarchies (must come after fespaces so the base fespace is available)
  registerMooseObjectTask("add_mfem_fespace_hierarchies", MFEMFESpaceHierarchy, false);
  addTaskDependency("add_mfem_fespace_hierarchies", "add_mfem_fespaces");
 
  // variables must wait for hierarchies since a variable may reference a hierarchy's
  // finest level via fespace_hierarchy = ...
  addTaskDependency("add_variable", "add_mfem_fespace_hierarchies");
  addTaskDependency("add_aux_variable", "add_mfem_fespace_hierarchies");
  addTaskDependency("add_elemental_field_variable", "add_mfem_fespace_hierarchies");
  // kernels only need fespaces, not hierarchies
  addTaskDependency("add_kernel", "add_mfem_fespaces");
 
  // add QuadratureFunctions
  registerMooseObjectTask("add_mfem_quadrature_functions", MFEMQuadratureFunction, false);
  // after the last task declaring coefficients the quadrature functions may project
  addTaskDependency("add_mfem_quadrature_functions", "add_functor_material");
  // before the tasks constructing objects that may consume the declared coefficients
  addTaskDependency("add_kernel", "add_mfem_quadrature_functions");
  addTaskDependency("add_bc", "add_mfem_quadrature_functions");
  addTaskDependency("add_aux_kernel", "add_mfem_quadrature_functions");
 
  // add complex kernels
  registerMooseObjectTask("add_mfem_complex_kernel_components", Kernel, false);
  registerMooseObjectTask("add_mfem_complex_bc_components", BoundaryCondition, false);
  addTaskDependency("add_mfem_complex_kernel_components", "add_mfem_fespaces");
  addTaskDependency("add_mfem_complex_bc_components", "add_mfem_fespaces");
  addTaskDependency("add_mfem_complex_kernel_components", "add_kernel");
  addTaskDependency("add_mfem_complex_bc_components", "add_bc");
 
  // set mesh FE space
  registerTask("set_mesh_fe_space", true);
  addTaskDependency("set_mesh_fe_space", "add_variable");
  addTaskDependency("set_mesh_fe_space", "init_mesh");
 

adOffset() [1/2]

std::size_t Moose::adOffset ( unsigned int  var_num, std::size_t  max_dofs_per_elem, DGJacobianType  dg_jacobian_type, unsigned int  num_vars_in_system = 0  )

inline

Definition at line 108 of file ADUtils.h.

{
  if (dg_jacobian_type == DGJacobianType::ElementElement ||
      dg_jacobian_type == DGJacobianType::NeighborElement)
    return adOffset(var_num, max_dofs_per_elem, ElementType::Element);
  else
    return adOffset(var_num, max_dofs_per_elem, ElementType::Neighbor, num_vars_in_system);
}

adOffset() [2/2]

std::size_t Moose::adOffset ( unsigned int  var_num, std::size_t  max_dofs_per_elem, ElementType  element_type = ElementType::Element, unsigned int  num_vars_in_system = 0  )

inline

Helper function for computing automatic differentiation offset.

Let's explain how our derivative index numbering scheme works:

Let's just think about continuous finite elements for a second. We use a variable major numbering scheme, such that each variables indices are in a contiguous block. Let's imagine we have two variables, u and v, and we're on a QUAD4. The AD indices will be ordered like this:

u0, u1, u2, u3, v0, v1, v2, v3

max_dofs_per_elem should be for a QUAD4: 4. For a QUAD9, 9. HEX27, 27. Etc. For CFEM the offset will be simply be the max_dofs_per_elem number times the var_num. So for u on a QUAD4: 4 * 0 = 0. For v: 4 * 1. So u indices start at index 0, v indices start at index 4.

With DFEM or interface kernels it's a little more complicated. We essentially already have an indices block that is num_vars_in_system * max_dofs_per_elem long, so in our two var, QUAD4 example: 4 * 2 = 8. So what we do is that if we are on a neighbor element, we do an additional offset by num_vars_in_system * max_dofs_per_elem. So now our derivative indices are ordered like this:

u0, u1, u2, u3, v0, v1, v2, v3, u0_neighbor, u1_neighbor, u2_neighbor, u3_neighbor, v0_neighbor, v1_neighbor, v2_neighbor, v3_neighbor

Finally if a lower-dimensional element is involved, then we another offset of num_vars_in_system * max_dofs_per_elem:

u0, u1, u2, u3, v0, v1, v2, v3, u0_neighbor, u1_neighbor, u2_neighbor, u3_neighbor, v0_neighbor, v1_neighbor, v2_neighbor, v3_neighbor, u0_lower, u1_lower, u2_lower, u3_lower, v0_lower, v1_lower, v2_lower, v3_lower

Note that a lower dimensional block will have less indices than a higher dimensional one, but we do not optimize for that consideration at this time

Parameters

var_num	The variable number we are calculating the offset for
max_dofs_per_elem	The maximum number of degrees of freedom for any one variable on an element
element_type	The "type" of element that we are on. Current options are ElementType::Element, ElementType::Neighbor, and ElementType::Lower
num_vars_in_system	The number of vars in the system. This is used in offset calculation unless element_type is ElementType::Element

Returns

The automatic differentiation indexing offset

Definition at line 78 of file ADUtils.h.

{
  // If our element type is anything other than ElementType::Element, then the user must
  // supply num_vars_in_system in order to calculate the offset
  mooseAssert(element_type == ElementType::Element || num_vars_in_system,
              "If our element type is anything other than ElementType::Element, then you "
              "must supply num_vars_in_system in order to calculate the offset");
 
  switch (element_type)
  {
    case ElementType::Element:
      return var_num * max_dofs_per_elem;
 
    case ElementType::Neighbor:
      return num_vars_in_system * max_dofs_per_elem + var_num * max_dofs_per_elem;
 
    case ElementType::Lower:
      return 2 * num_vars_in_system * max_dofs_per_elem + var_num * max_dofs_per_elem;
 
    default:
      mooseError(
          "Unsupported element type ",
          static_cast<typename std::underlying_type<decltype(element_type)>::type>(element_type));
  }
}

Referenced by adOffset(), and globalDofIndexToDerivative().

ADRealToGenericReal()

template<bool is_ad>

GenericReal< is_ad > Moose::ADRealToGenericReal

(

const ADReal &

u_ad

)

Converts an ADReal to a GenericReal<is_ad>

Definition at line 161 of file ADUtils.h.

{
  if constexpr (is_ad)
    return u_ad;
  else
    return u_ad.value();
}

applyIndices()

template<typename T >

void Moose::applyIndices	(	T &	container,
		const std::vector< size_t > &	indices
	)

Uses indices created by the indirectSort function to sort the given container (which must support random access, resizing, and std::swap.

Definition at line 116 of file IndirectSort.h.

{
  T tmp;
  tmp.resize(container.size());
  for (size_t i = 0; i < indices.size(); i++)
    tmp[i] = container[indices[i]];
  std::swap(tmp, container);
}

assemble_matrix()

void Moose::assemble_matrix	(	EquationSystems &	es,
		const std::string &	system_name
	)

Definition at line 42 of file NonlinearEigenSystem.C.

{
  EigenProblem * p = es.parameters.get<EigenProblem *>("_eigen_problem");
  auto & eigen_system = es.get_system<libMesh::CondensedEigenSystem>(system_name);
  NonlinearEigenSystem & eigen_nl =
      p->getNonlinearEigenSystem(/*nl_sys_num=*/eigen_system.number());
 
  // If this is a nonlinear eigenvalue problem,
  // we do not need to assemble anything
  if (p->isNonlinearEigenvalueSolver(eigen_nl.number()))
  {
    // If you want an efficient eigensolver,
    // please use PETSc 3.13 or newer.
    // We need to do an unnecessary assembly,
    // if you use PETSc that is older than 3.13.
#if PETSC_RELEASE_LESS_THAN(3, 13, 0)
    if (eigen_system.has_matrix_B())
      p->computeJacobianTag(*eigen_system.current_local_solution,
                            eigen_system.get_matrix_B(),
                            eigen_nl.eigenMatrixTag());
#endif
    return;
  }
 
#if !PETSC_RELEASE_LESS_THAN(3, 13, 0)
  // If we use shell matrices and do not use a shell preconditioning matrix,
  // we only need to form a preconditioning matrix
  if (eigen_system.use_shell_matrices() && !eigen_system.use_shell_precond_matrix())
  {
    p->computeJacobianTag(*eigen_system.current_local_solution,
                          eigen_system.get_precond_matrix(),
                          eigen_nl.precondMatrixTag());
    return;
  }
#endif
  // If it is a linear generalized eigenvalue problem,
  // we assemble A and B together
  if (eigen_system.generalized())
  {
    p->computeJacobianAB(*eigen_system.current_local_solution,
                         eigen_system.get_matrix_A(),
                         eigen_system.get_matrix_B(),
                         eigen_nl.nonEigenMatrixTag(),
                         eigen_nl.eigenMatrixTag());
#if LIBMESH_HAVE_SLEPC
    if (p->negativeSignEigenKernel())
      LibmeshPetscCallA(
          p->comm().get(),
          MatScale(cast_ref<PetscMatrix<Number> &>(eigen_system.get_matrix_B()).mat(), -1.0));
#endif
    return;
  }
 
  // If it is a linear eigenvalue problem, we assemble matrix A
  {
    p->computeJacobianTag(*eigen_system.current_local_solution,
                          eigen_system.get_matrix_A(),
                          eigen_nl.nonEigenMatrixTag());
 
    return;
  }
}

Referenced by EigenProblem::init().

associateSyntax()

void Moose::associateSyntax	(	Syntax &	syntax,
		ActionFactory &	action_factory
	)

Definition at line 847 of file Moose.C.

associateSyntaxInner()

void Moose::associateSyntaxInner	(	Syntax &	syntax,
		ActionFactory &	action_factory
	)

Note: the optional third parameter is used to differentiate which task is satisfied based on the syntax encountered for classes which are registered to satisfy more than one task

Variable/AuxVariable Actions

Note: the optional third parameter is used to differentiate which task is satisfied based on the syntax encountered for classes which are registered to satisfy more than one task

Variable/AuxVariable Actions

Definition at line 610 of file Moose.C.

       : Placeholder "no_action" actions must be put in places where it is possible to match an
 *       object with a star or a more specific parent later on. (i.e. where one needs to negate the
 *       '*' matching prematurely).
 */
void
registerActions(Syntax & syntax, ActionFactory & action_factory)
{
  mooseDeprecated("use registerAll instead of registerActions");
  registerActions(syntax, action_factory, {"MooseApp"});
}
 
void
registerActions(Syntax & syntax,
                ActionFactory & action_factory,
                const std::set<std::string> & obj_labels)
{
  Registry::registerActionsTo(action_factory, obj_labels);
 
  // Add these actions here so they are always executed last, without setting any dependency
  registerTask("dump_objects", false);
  registerTask("finish_input_file_output", false);
}
 
void
associateSyntaxInner(Syntax & syntax, ActionFactory & /*action_factory*/)
{
  registerSyntax("DiffusionCG", "Physics/Diffusion/ContinuousGalerkin/*");
  registerSyntax("DiffusionFV", "Physics/Diffusion/FiniteVolume/*");
 
  registerSyntax("AddActionComponentAction", "ActionComponents/*");
  registerSyntax("CombineComponentsMeshes", "ActionComponents");
 
  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "check_copy_nodal_vars");
  registerSyntaxTask("CopyNodalVarsAction", "Variables/*", "copy_nodal_vars");
  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "check_copy_nodal_vars");
  registerSyntaxTask("CopyNodalVarsAction", "AuxVariables/*", "copy_nodal_aux_vars");
 
  registerSyntaxTask("AddKernelAction", "Kernels/*", "add_kernel");
  registerSyntaxTask("AddNodalKernelAction", "NodalKernels/*", "add_nodal_kernel");
  registerSyntaxTask("AddKernelAction", "AuxKernels/*", "add_aux_kernel");
 
  registerSyntaxTask("AddHDGKernelAction", "HDGKernels/*", "add_hybridized_kernel");
 
  registerSyntax("AddAuxKernelAction", "AuxVariables/*/AuxKernel");
 
  registerSyntaxTask("AddScalarKernelAction", "ScalarKernels/*", "add_scalar_kernel");
  registerSyntaxTask("AddScalarKernelAction", "AuxScalarKernels/*", "add_aux_scalar_kernel");
 
  registerSyntaxTask("AddBCAction", "BCs/*", "add_bc");
 
  registerSyntax("CreateProblemAction", "Problem");
  registerSyntax("DynamicObjectRegistrationAction", "Problem");
 
  registerSyntax("SetupMeshAction", "Mesh");
  registerSyntax("SetupMeshCompleteAction", "Mesh");
  // Components should be able create a Mesh without a Mesh block
  registerSyntax("CreateMeshSetupActionsForComponents", "ActionComponents");
  registerSyntax("CreateDisplacedProblemAction", "Mesh");
  registerSyntax("DisplayGhostingAction", "Mesh");
  registerSyntax("AddMeshGeneratorAction", "Mesh/*");
  registerSyntaxTask("EmptyAction", "Mesh/BatchMeshGeneratorAction", "no_action");
  registerSyntax("BatchMeshGeneratorAction", "Mesh/BatchMeshGeneratorAction/*");
  registerSyntax("ElementIDOutputAction", "Mesh");
  syntax.registerSyntaxType("Mesh/*", "MeshGeneratorName");
 
  registerSyntax("AddFunctionAction", "Functions/*");
  syntax.registerSyntaxType("Functions/*", "FunctionName");
 
  registerSyntax("AddMeshDivisionAction", "MeshDivisions/*");
  syntax.registerSyntaxType("MeshDivisions/*", "MeshDivisionName");
  registerSyntax("AddConvergenceAction", "Convergence/*");
  syntax.registerSyntaxType("Convergence/*", "ConvergenceName");
 
  registerSyntax("GlobalParamsAction", "GlobalParams");
 
  registerSyntax("AddDistributionAction", "Distributions/*");
  syntax.registerSyntaxType("Distributions/*", "DistributionName");
 
  registerSyntax("AddSamplerAction", "Samplers/*");
  syntax.registerSyntaxType("Samplers/*", "SamplerName");
 
  registerSyntax("SetupDebugAction", "Debug");
  registerSyntax("SetupResidualDebugAction", "Debug");
 
  registerSyntax("AddVariableAction", "Variables/*");
  syntax.registerSyntaxType("Variables/*", "VariableName");
  syntax.registerSyntaxType("Variables/*", "NonlinearVariableName");
 
  registerSyntax("AddICAction", "Variables/*/InitialCondition");
  registerSyntax("AddFVICAction", "Variables/*/FVInitialCondition");
 
  registerSyntax("AddAuxVariableAction", "AuxVariables/*");
  syntax.registerSyntaxType("AuxVariables/*", "VariableName");
  syntax.registerSyntaxType("AuxVariables/*", "AuxVariableName");
 
  registerSyntax("AddICAction", "AuxVariables/*/InitialCondition");
  registerSyntax("AddFVICAction", "AuxVariables/*/FVInitialCondition");
 
  registerSyntaxTask("EmptyAction", "BCs/Periodic", "no_action"); // placeholder
  registerSyntax("AddPeriodicBCAction", "BCs/Periodic/*");
 
  registerSyntaxTask("AddInitialConditionAction", "ICs/*", "add_ic");
  registerSyntaxTask("AddFVInitialConditionAction", "FVICs/*", "add_fv_ic");
 
  registerSyntax("AddMaterialAction", "Materials/*");
  syntax.registerSyntaxType("Materials/*", "MaterialName");
 
  registerSyntax("AddFunctorMaterialAction", "FunctorMaterials/*");
  syntax.registerSyntaxType("FunctorMaterials/*", "MaterialName");
 
  registerSyntax("AddPostprocessorAction", "Postprocessors/*");
  syntax.registerSyntaxType("Postprocessors/*", "PostprocessorName");
  syntax.registerSyntaxType("Postprocessors/*", "UserObjectName");
 
  registerSyntax("AddVectorPostprocessorAction", "VectorPostprocessors/*");
  syntax.registerSyntaxType("VectorPostprocessors/*", "VectorPostprocessorName");
 
  registerSyntax("AddReporterAction", "Reporters/*");
  syntax.registerSyntaxType("Reporters/*", "ReporterName");
 
  registerSyntax("AddPositionsAction", "Positions/*");
  syntax.registerSyntaxType("Positions/*", "PositionsName");
 
  registerSyntax("AddTimesAction", "Times/*");
  syntax.registerSyntaxType("Times/*", "TimesName");
 
  registerSyntax("AddDamperAction", "Dampers/*");
 
  registerSyntax("AddOutputAction", "Outputs/*");
  registerSyntax("CommonOutputAction", "Outputs");
  registerSyntax("MaterialOutputAction", "Outputs");
  registerSyntax("AutoCheckpointAction", "Outputs");
  syntax.registerSyntaxType("Outputs/*", "OutputName");
 
  // Note: Preconditioner Actions will be built by this setup action
  registerSyntax("SetupPreconditionerAction", "Preconditioning/*");
  registerSyntax("AddFieldSplitAction", "Preconditioning/*/*");
 
  registerSyntax("CreateExecutionerAction", "Executioner");
  registerSyntax("ReadExecutorParamsAction", "Executors/*");
 
  registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeSteppers/*", "add_time_steppers");
  registerSyntaxTask("AddTimeStepperAction", "Executioner/TimeStepper", "add_time_stepper");
  registerSyntaxTask(
      "ComposeTimeStepperAction", "Executioner/TimeSteppers", "compose_time_stepper");
  registerSyntaxTask(
      "SetupTimeIntegratorAction", "Executioner/TimeIntegrators/*", "setup_time_integrators");
  registerSyntaxTask(
      "SetupTimeIntegratorAction", "Executioner/TimeIntegrator", "setup_time_integrator");
  syntax.registerSyntaxType("Executors/*", "ExecutorName");
 
  registerSyntax("SetupQuadratureAction", "Executioner/Quadrature");
  registerSyntax("SetupPredictorAction", "Executioner/Predictor");
#ifdef LIBMESH_ENABLE_AMR
  registerSyntax("AdaptivityAction", "Executioner/Adaptivity");
#endif
 
  registerSyntax("PartitionerAction", "Mesh/Partitioner");
 
  registerSyntax("AddDiracKernelAction", "DiracKernels/*");
 
  registerSyntax("AddDGKernelAction", "DGKernels/*");
  registerSyntax("AddFVKernelAction", "FVKernels/*");
  registerSyntax("AddFVBCAction", "FVBCs/*");
  registerSyntax("AddLinearFVBCAction", "LinearFVBCs/*");
  registerSyntax("AddFVInterfaceKernelAction", "FVInterfaceKernels/*");
  registerSyntax("CheckFVBCAction", "FVBCs");
 
  registerSyntax("AddLinearFVKernelAction", "LinearFVKernels/*");
 
  registerSyntax("AddInterfaceKernelAction", "InterfaceKernels/*");
 
  registerSyntax("AddConstraintAction", "Constraints/*");
 
  registerSyntax("AddControlAction", "Controls/*");
  registerSyntax("AddChainControlAction", "ChainControls/*");
  registerSyntax("AddBoundAction", "Bounds/*");
  registerSyntax("AddBoundsVectorsAction", "Bounds");
 
  // UserObject and some derived classes
  registerSyntax("AddUserObjectAction", "UserObjects/*");
  syntax.registerSyntaxType("UserObjects/*", "UserObjectName");
 
  registerSyntax("AddCorrectorAction", "Correctors/*");
  syntax.registerSyntaxType("Correctors/*", "UserObjectName");
 
  registerSyntax("AddMeshModifiersAction", "MeshModifiers/*");
  syntax.registerSyntaxType("MeshModifiers/*", "UserObjectName");
 
  registerSyntax("AddNodalNormalsAction", "NodalNormals");
 
  // FVInterpolationMethods
  registerSyntax("AddFVInterpolationMethodAction", "FVInterpolationMethods/*");
  syntax.registerSyntaxType("FVInterpolationMethods/*", "InterpolationMethodName");
 
  // FVGradientMethods
  registerSyntax("AddFVGradientMethodAction", "FVGradientMethods/*");
  syntax.registerSyntaxType("FVGradientMethods/*", "GradientMethodName");
 
  // Indicator
  registerSyntax("AddElementalFieldAction", "Adaptivity/Indicators/*");
  registerSyntax("AddIndicatorAction", "Adaptivity/Indicators/*");
  syntax.registerSyntaxType("Adaptivity/Indicators/*", "IndicatorName");
 
  // Marker
  registerSyntax("AddElementalFieldAction", "Adaptivity/Markers/*");
  registerSyntax("AddMarkerAction", "Adaptivity/Markers/*");
  syntax.registerSyntaxType("Adaptivity/Markers/*", "MarkerName");
 
  // New Adaptivity System
  registerSyntax("SetAdaptivityOptionsAction", "Adaptivity");
 
  // Deprecated Block
  registerSyntax("DeprecatedBlockAction", "DeprecatedBlock");
 
  // Multi Apps
  registerSyntax("AddMultiAppAction", "MultiApps/*");
  syntax.registerSyntaxType("MultiApps/*", "MultiAppName");
 
  // Transfers
  registerSyntax("AddTransferAction", "Transfers/*");
 
  // Material derivative test
  registerSyntaxTask("EmptyAction", "Debug/MaterialDerivativeTest", "no_action"); // placeholder

Referenced by registerAll(), and setColorConsole().

colorConsole()

bool Moose::colorConsole

(

)

Returns whether Console coloring is turned on (default: true).

Definition at line 871 of file Moose.C.

commonAdaptivityParams()

InputParameters Moose::commonAdaptivityParams

(

)

Definition at line 23 of file SetAdaptivityOptionsAction.C.

{
  InputParameters params = Action::validParams();
  params.addParam<unsigned int>(
      "steps", 0, "The number of adaptive steps to use when doing a Steady simulation.");
  params.addRangeCheckedParam<unsigned int>(
      "interval", 1, "interval>0", "The number of time steps betweeen each adaptivity phase");
  params.addParam<unsigned int>(
      "max_h_level",
      0,
      "Maximum number of times a single element can be refined. If 0 then infinite.");
  params.addDeprecatedParam<Real>(
      "start_time",
      -std::numeric_limits<Real>::max(),
      "The time that adaptivity will be active after.",
      "'start_time' will be deprecated in the future. You can get identical behavior by using the "
      "Controls system to set 'enable'.");
  params.addDeprecatedParam<Real>(
      "stop_time",
      std::numeric_limits<Real>::max(),
      "The time after which adaptivity will no longer be active.",
      "'stop_time' will be deprecated in the future. You can get identical behavior by using the "
      "Controls system to set 'enable'.");
  params.addParam<bool>("enable", true, "Whether adaptivity should be enabled.");
  params.declareControllable("enable");
  params.addParam<unsigned int>(
      "cycles_per_step",
      1,
      "The number of adaptive steps to use when on each timestep during a Transient simulation.");
  params.addParam<bool>(
      "recompute_markers_during_cycles", false, "Recompute markers during adaptivity cycles");
  MooseEnum adaptivity("h=0 p=1 hp=2", "h");
  params.addParam<MooseEnum>(
      "adaptivity_type", adaptivity, "Select between h, p or hp mesh adaptivity");
  return params;
}

Referenced by AdaptivityAction::validParams(), and SetAdaptivityOptionsAction::validParams().

compute_bounds()

void Moose::compute_bounds	(	NumericVector< Number > &	lower,
		NumericVector< Number > &	upper,
		NonlinearImplicitSystem &	sys
	)

Definition at line 45 of file NonlinearSystem.C.

{
  FEProblemBase * p =
      sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
  p->computeBounds(sys, lower, upper);
}

Referenced by NonlinearSystem::NonlinearSystem().

compute_jacobian()

void Moose::compute_jacobian	(	const NumericVector< Number > &	soln,
		SparseMatrix< Number > &	jacobian,
		NonlinearImplicitSystem &	sys
	)

Definition at line 35 of file NonlinearSystem.C.

{
  FEProblemBase * p =
      sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
  p->computeJacobianSys(sys, soln, jacobian);
}

Referenced by NonlinearSystem::NonlinearSystem(), and NonlinearSystem::setupColoringFiniteDifferencedPreconditioner().

compute_linear_system()

void Moose::compute_linear_system	(	libMesh::EquationSystems &	es,
		const std::string &	system_name
	)

Definition at line 64 of file LinearSystem.C.

{
  FEProblemBase * p = es.parameters.get<FEProblemBase *>("_fe_problem_base");
  auto & sys = p->getLinearSystem(p->linearSysNum(system_name));
  auto & lin_sys = sys.linearImplicitSystem();
  auto & matrix = *(sys.linearImplicitSystem().matrix);
  auto & rhs = *(sys.linearImplicitSystem().rhs);
  p->computeLinearSystemSys(lin_sys, matrix, rhs);
}

Referenced by LinearSystem::LinearSystem().

compute_nearnullspace()

void Moose::compute_nearnullspace	(	std::vector< NumericVector< Number > * > &	sp,
		NonlinearImplicitSystem &	sys
	)

Definition at line 72 of file NonlinearSystem.C.

{
  FEProblemBase * p =
      sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
  p->computeNearNullSpace(sys, sp);
}

Referenced by NonlinearSystem::NonlinearSystem().

compute_nullspace()

void Moose::compute_nullspace	(	std::vector< NumericVector< Number > * > &	sp,
		NonlinearImplicitSystem &	sys
	)

Definition at line 55 of file NonlinearSystem.C.

{
  FEProblemBase * p =
      sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
  p->computeNullSpace(sys, sp);
}

Referenced by NonlinearSystem::NonlinearSystem().

compute_postcheck()

void Moose::compute_postcheck	(	const NumericVector< Number > &	old_soln,
		NumericVector< Number > &	search_direction,
		NumericVector< Number > &	new_soln,
		bool &	changed_search_direction,
		bool &	changed_new_soln,
		NonlinearImplicitSystem &	sys
	)

Definition at line 80 of file NonlinearSystem.C.

{
  FEProblemBase * p =
      sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
  p->computePostCheck(
      sys, old_soln, search_direction, new_soln, changed_search_direction, changed_new_soln);
}

Referenced by NonlinearSystem::solve().

compute_transpose_nullspace()

void Moose::compute_transpose_nullspace	(	std::vector< NumericVector< Number > * > &	sp,
		NonlinearImplicitSystem &	sys
	)

Definition at line 63 of file NonlinearSystem.C.

{
  FEProblemBase * p =
      sys.get_equation_systems().parameters.get<FEProblemBase *>("_fe_problem_base");
  p->computeTransposeNullSpace(sys, sp);
}

Referenced by NonlinearSystem::NonlinearSystem().

createMapFromVectorAndMultiMooseEnum()

template<typename T >

std::map< T, MooseEnum > Moose::createMapFromVectorAndMultiMooseEnum	(	const std::vector< T > &	keys,
		const MultiMooseEnum &	values
	)

Create a map from a vector of keys and MultiMooseEnum acting as a vector.

Parameters

keys	the vector of the keys
values	the MultiMooseEnum acting as a vector of the values

Template Parameters

T	the type of the keys

Definition at line 58 of file MapConversionUtils.h.

{
  std::map<T, MooseEnum> map;
  mooseAssert(keys.size() == values.size(),
              "Map should be made from keys and values of the same size");
  // No values have been specified. We cant form a map of empty MooseEnum
  if (!values.size())
    return map;
  std::transform(keys.begin(),
                 keys.end(),
                 values.begin(),
                 std::inserter(map, map.end()),
                 [values](const T & a, const MooseEnumItem & b)
                 {
                   // Create a MooseEnum from the available values in the MultiMooseEnum and an
                   // actual current active item from that same MultiMooseEnum
                   MooseEnum single_value(values.getRawNames(), b.name());
                   return std::make_pair(a, single_value);
                 });
  return map;
}

createMapFromVectors()

template<typename T , typename C >

std::map< T, C > Moose::createMapFromVectors	(	const std::vector< T > &	keys,
		const std::vector< C > &	values
	)

Create a map from two vectors.

Parameters

keys	the vector of the keys
values	the vector of the values

Template Parameters

T	the type of the keys
C	the type of the values

Definition at line 36 of file MapConversionUtils.h.

{
  std::map<T, C> map;
  mooseAssert(keys.size() == values.size(),
              "Map should be made from keys (" + std::to_string(keys.size()) + ") and values (" +
                  std::to_string(values.size()) + ") of the same size");
 
  // No values have been specified.
  if (!values.size())
  {
    return map;
  }
  std::transform(keys.begin(),
                 keys.end(),
                 values.begin(),
                 std::inserter(map, map.end()),
                 [](const T & a, const C & b) { return std::make_pair(a, b); });
  return map;
}

createMooseApp()

std::unique_ptr< MooseApp > Moose::createMooseApp	(	const std::string &	default_app_type,
		int	argc,
		char *	argv[]
	)

Create a MooseApp from command-line arguments.

Definition at line 27 of file MooseMain.C.

{
  // Parse the command line early in order to determine the application type, from:
  // - the input file, to load and search for Application/type
  // - the --app command line argument
  // - The Application/type= hit command line argument
  auto command_line_params = emptyInputParameters();
  {
    CommandLine cl(argc, argv);
    cl.parse();
    MooseApp::addInputParam(command_line_params);
    MooseApp::addAppParam(command_line_params);
    cl.populateCommandLineParams(command_line_params);
 
    // Do not allow overriding Application/type= for subapps
    for (const auto & arg : cl.getArguments())
      if (std::regex_match(arg, std::regex("[A-Za-z0-9]*:Application/.*")))
        mooseError(
            "For command line argument '",
            arg,
            "': overriding the application type for MultiApps via command line is not allowed.");
  }
  const auto & input_filenames = command_line_params.get<std::vector<std::string>>("input_file");
 
  // Parse command line arguments so that we can get the "--app" entry (if any) and the HIT
  // command line arguments for the Parser
  auto command_line = std::make_unique<CommandLine>(argc, argv);
  command_line->parse();
 
  // Setup the parser with the input and the HIT parameters from the command line. The parse
  // will also look for "Application/type=" in input to specify the application type
  auto parser = std::make_unique<Parser>(input_filenames);
  parser->setAppType(default_app_type);
  parser->setCommandLineParams(command_line->buildHitParams());
  parser->parse();
 
  // Search the command line for either --app or Application/type and let the last one win
  for (const auto & entry : std::as_const(*command_line).getEntries())
    if (!entry.subapp_name && entry.value &&
        (entry.name == "--app" || entry.name == "Application/type"))
      parser->setAppType(*entry.value);
 
  const auto & app_type = parser->getAppType();
  if (!AppFactory::instance().isRegistered(app_type))
    mooseError("'", app_type, "' is not a registered application type.");
 
  // Create an instance of the application and store it in a smart pointer for easy cleanup
  return AppFactory::create(std::move(parser), std::move(command_line));
}

Referenced by main().

currentState()

StateArg Moose::currentState ( )

inline

Definition at line 156 of file MooseFunctorArguments.h.

{
  return {};
}

Referenced by MooseVariableDataFV< OutputType >::computeAD(), GradientJumpIndicator::computeQpIntegral(), MaterialFunctorConverterTempl< T >::computeQpProperties(), FunctorNeumannBC::computeQpResidual(), FunctorDiracKernel::computeQpResidual(), FunctorDirichletBC::computeQpValue(), TransientInterface::determineState(), FunctorNodalCorrector::execute(), FunctorChangeFunctorMaterialTempl< is_ad >::FunctorChangeFunctorMaterialTempl(), FunctorIC::gradient(), ComputeLinearFVGreenGaussGradientVolumeThread::operator()(), FunctorKernel::precomputeQpResidual(), Moose::FunctorBase< T >::queryFVArgCache(), and FunctorIC::value().

derivInsert() [1/2]

template<std::size_t N>

void Moose::derivInsert ( NumberArray< N, Real > &  derivs, dof_id_type  index, Real  value  )

inline

Definition at line 19 of file NumberArrayOps.h.

{
  mooseAssert(index < MOOSE_AD_MAX_DOFS_PER_ELEM,
              "The requested derivative index "
                  << index << " is not less than " << MOOSE_AD_MAX_DOFS_PER_ELEM
                  << ". You can run `configure --with-derivative-size=<n>` to request a larger "
                     "derivative container.");
  derivs[index] = value;
}

derivInsert() [2/2]

template<std::size_t N>

void Moose::derivInsert ( SemiDynamicSparseNumberArray< Real, libMesh::dof_id_type, NWrapper< N > > &  derivs, libMesh::dof_id_type  index, Real  value  )

inline

Definition at line 21 of file ADReal.h.

{
#ifndef NDEBUG
  try
  {
    derivs.insert(index) = value;
  }
  catch (MetaPhysicL::LogicError &)
  {
    // We don't want to use a MooseError here to keep the list of includes in parsed ADReal logic
    // minimal
    libmesh_error_msg(
        "The last insertion into the sparse derivative storage container exceeded the "
        "underlying array size. Consider running `configure --with-derivative-size=<n>` to "
        "obtain a larger underlying container");
  }
#else
  derivs.insert(index) = value;
#endif
}

Referenced by MooseVariableScalar::computeAD(), MooseVariableDataFV< OutputType >::computeAD(), Assembly::computeFaceMap(), ADPenaltyPeriodicSegmentalConstraint::computeQpResidual(), ADPeriodicSegmentalConstraint::computeQpResidual(), ADPenaltyPeriodicSegmentalConstraint::computeScalarQpResidual(), Assembly::computeSinglePointMapAD(), MooseVariableFE< OutputType >::computeSolution(), MooseVariableScalar::evaluate(), MooseVariableFE< OutputType >::evaluate(), MooseVariableData< OutputType >::fetchADDofValues(), and MooseVariableDataFV< OutputType >::fetchADDofValues().

doDerivatives()

bool Moose::doDerivatives	(	const SubProblem &	subproblem,
		const SystemBase &	sys
	)

Returns

whether we should be doing derivatives

Definition at line 83 of file ADUtils.C.

{
  return ADReal::do_derivatives && sys.number() == subproblem.currentNlSysNum();
}

Referenced by MooseVariableFE< OutputType >::computeSolution(), MooseVariableScalar::evaluate(), MooseVariableFE< OutputType >::evaluate(), and MooseVariableData< OutputType >::fetchADDofValues().

elementsIntersectedByLine() [1/2]

void Moose::elementsIntersectedByLine	(	const Point &	p0,
		const Point &	p1,
		const MeshBase &	,
		const PointLocatorBase &	point_locator,
		std::vector< Elem * > &	intersected_elems,
		std::vector< LineSegment > &	segments
	)

Definition at line 192 of file RayTracing.C.

{
  // Make sure our list is clear
  intersected_elems.clear();
 
  // Find the starting element
  const Elem * first_elem = point_locator(p0);
 
  // Quick return if can't even locate the first element.
  if (!first_elem)
    return;
 
  intersected_elems.push_back(const_cast<Elem *>(first_elem));
 
  // Make a LineSegment object out of our two points for ease:
  LineSegment line_segment = LineSegment(p0, p1);
 
  // Find 'em!
  recursivelyFindElementsIntersectedByLine(
      line_segment, first_elem, -1, p0, intersected_elems, segments);
}

elementsIntersectedByLine() [2/2]

void Moose::elementsIntersectedByLine	(	const Point &	p0,
		const Point &	p1,
		const MeshBase &	mesh,
		const libMesh::PointLocatorBase &	point_locator,
		std::vector< Elem * > &	intersected_elems,
		std::vector< LineSegment > &	segments
	)

Find all of the elements intersected by a line.

The line is given as the beginning and ending points

Parameters

p0	The beginning of the line
p1	The end of the line
intersected_elems	The elements intersected by the line. Will be empty if there are no intersections.
segments	The line segments across each element

Referenced by ElementsAlongLine::execute(), IntersectionPointsAlongLine::execute(), and LineMaterialSamplerBase< T >::execute().

elementsIntersectedByPlane() [1/4]

void Moose::elementsIntersectedByPlane	(	const libMesh::Point &	p0,
		const libMesh::Point &	normal,
		const libMesh::MeshBase &	mesh,
		std::vector< const libMesh::Elem * > &	intersected_elems
	)

Find all of the elements intersected by a plane.

The plane is given as a point and a normal vector.

Parameters

p0	Point in plane.
normal	Normal vector to plane.
intersected_elems	The elements intersected by the plane. Will be empty if there are no intersections.

Referenced by ElementsAlongPlane::execute().

elementsIntersectedByPlane() [2/4]

void Moose::elementsIntersectedByPlane	(	const libMesh::Point &	p0,
		const libMesh::Point &	p1,
		const libMesh::Point &	p2,
		const libMesh::MeshBase &	mesh,
		std::vector< const libMesh::Elem * > &	intersected_elems
	)

Find all of the elements intersected by a plane.

The plane is given as three points in the plane.

Parameters

p0	Point in plane.
p1	Point in plane.
p2	Point in plane.
intersected_elems	The elements intersected by the plane. Will be empty if there are no intersections.

elementsIntersectedByPlane() [3/4]

void Moose::elementsIntersectedByPlane	(	const Point &	p0,
		const Point &	normal,
		const MeshBase &	mesh,
		std::vector< const Elem * > &	intersected_elems
	)

Definition at line 53 of file ElementsIntersectedByPlane.C.

{
  // Make sure our list is clear
  intersected_elems.clear();
 
  // Create plane from point and normal:
  libMesh::Plane plane(p0, normal);
 
  // Find 'em!
  findElementsIntersectedByPlane(plane, mesh, intersected_elems);
}

elementsIntersectedByPlane() [4/4]

void Moose::elementsIntersectedByPlane	(	const Point &	p0,
		const Point &	p1,
		const Point &	p2,
		const MeshBase &	mesh,
		std::vector< const Elem * > &	intersected_elems
	)

Definition at line 69 of file ElementsIntersectedByPlane.C.

{
  // Make sure our list is clear
  intersected_elems.clear();
 
  // Create plane from three points:
  libMesh::Plane plane(p0, p1, p2);
 
  // Find 'em!
  findElementsIntersectedByPlane(plane, mesh, intersected_elems);
}

enumerate() [1/3]

template<class Container >

_enumerate_range< typename Container::const_iterator > Moose::enumerate

(

const Container &

content

)

Definition at line 68 of file Enumerate.h.

{
  return _enumerate_range<typename Container::const_iterator>(
      std::begin(content), std::end(content), 0);
}

enumerate() [2/3]

template<class Container >

_enumerate_range< typename Container::iterator > Moose::enumerate

(

Container &

content

)

Definition at line 61 of file Enumerate.h.

{
  return _enumerate_range<typename Container::iterator>(std::begin(content), std::end(content), 0);
}

enumerate() [3/3]

template<class Iterator >

_enumerate_range< Iterator > Moose::enumerate	(	Iterator	first,
		Iterator	last,
		typename std::iterator_traits< Iterator >::difference_type	initial
	)

Enumerate function for iterating over a range and obtaining both a reference to the underlying type and an index simultaneously.

This method is forward-compatible with the C++17 structured bindings capability.

C++11 compatible usage:

for (auto it : Moose::enumerate(values)) _console << it.index() << ": " << it.value() << '
';

// Here the third argument is the starting index value for (auto it : Moose::enumerate(values.begin(), values.end(), 0)) _console << it.index() << ": " << it.value() << '
';

C++17 usage (DO NOT USE IN MOOSE):

for (auto [index, value] : Moose::enumerate(values)) _console << index << ": " << value << '
';

// Here the third argument is the starting index value for (auto [index, value] : Moose::enumerate(values.begin(), values.end(), 0)) _console << index << ": " << value << '
';

Definition at line 52 of file Enumerate.h.

{
  return _enumerate_range<Iterator>(first, last, initial);
}

Referenced by JvarMapInterfaceBase< T >::JvarMapInterfaceBase(), NearestPointAverage::nearestPointIndex(), NearestPointIntegralVariablePostprocessor::nearestPointIndex(), and NearestPointBase< UserObjectType, BaseType >::nearestUserObject().

fe_lagrange_1D_shape()

template<typename T >

T Moose::fe_lagrange_1D_shape	(	const Order	order,
		const unsigned int	i,
		const T &	xi
	)

Definition at line 20 of file MooseLagrangeHelpers.h.

{
  switch (order)
  {
      // Lagrange linears
    case libMesh::FIRST:
    {
      libmesh_assert_less(i, 2);
 
      switch (i)
      {
        case 0:
          return .5 * (1. - xi);
 
        case 1:
          return .5 * (1. + xi);
 
        default:
          mooseError("Invalid shape function index i = ", i);
      }
    }
 
      // Lagrange quadratics
    case libMesh::SECOND:
    {
      libmesh_assert_less(i, 3);
 
      switch (i)
      {
        case 0:
          return .5 * xi * (xi - 1.);
 
        case 1:
          return .5 * xi * (xi + 1);
 
        case 2:
          return (1. - xi * xi);
 
        default:
          mooseError("Invalid shape function index i = ", i);
      }
    }
 
      // Lagrange cubics
    case libMesh::THIRD:
    {
      libmesh_assert_less(i, 4);
 
      switch (i)
      {
        case 0:
          return 9. / 16. * (1. / 9. - xi * xi) * (xi - 1.);
 
        case 1:
          return -9. / 16. * (1. / 9. - xi * xi) * (xi + 1.);
 
        case 2:
          return 27. / 16. * (1. - xi * xi) * (1. / 3. - xi);
 
        case 3:
          return 27. / 16. * (1. - xi * xi) * (1. / 3. + xi);
 
        default:
          mooseError("Invalid shape function index i = ", i);
      }
    }
 
    default:
      mooseError("Unsupported order");
  }
}

Referenced by AutomaticMortarGeneration::buildMortarSegmentMesh(), fe_lagrange_2D_shape(), fe_lagrange_2D_shape_deriv(), AutomaticMortarGeneration::getNormals(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), and AutomaticMortarGeneration::projectSecondaryNodesSinglePair().

fe_lagrange_1D_shape_deriv()

template<typename T >

T Moose::fe_lagrange_1D_shape_deriv	(	const Order	order,
		const unsigned int	i,
		const T &	xi
	)

Definition at line 94 of file MooseLagrangeHelpers.h.

{
  switch (order)
  {
      // Lagrange linear shape function derivatives
    case libMesh::FIRST:
    {
      libmesh_assert_less(i, 2);
 
      switch (i)
      {
        case 0:
          return -.5;
 
        case 1:
          return .5;
 
        default:
          mooseError("Invalid shape function index i = ", i);
      }
    }
 
      // Lagrange quadratic shape function derivatives
    case libMesh::SECOND:
    {
      libmesh_assert_less(i, 3);
 
      switch (i)
      {
        case 0:
          return xi - .5;
 
        case 1:
          return xi + .5;
 
        case 2:
          return -2. * xi;
 
        default:
          mooseError("Invalid shape function index i = ", i);
      }
    }
 
      // Lagrange cubic shape function derivatives
    case libMesh::THIRD:
    {
      libmesh_assert_less(i, 4);
 
      switch (i)
      {
        case 0:
          return -9. / 16. * (3. * xi * xi - 2. * xi - 1. / 9.);
 
        case 1:
          return -9. / 16. * (-3. * xi * xi - 2. * xi + 1. / 9.);
 
        case 2:
          return 27. / 16. * (3. * xi * xi - 2. / 3. * xi - 1.);
 
        case 3:
          return 27. / 16. * (-3. * xi * xi - 2. / 3. * xi + 1.);
 
        default:
          mooseError("Invalid shape function index i = ", i);
      }
    }
 
    default:
      mooseError("Unsupported order");
  }
}

Referenced by fe_lagrange_2D_shape_deriv().

fe_lagrange_2D_shape()

template<typename T , template< typename > class VectorType>

T Moose::fe_lagrange_2D_shape	(	const libMesh::ElemType	type,
		const Order	order,
		const unsigned int	i,
		const VectorType< T > &	p
	)

Definition at line 169 of file MooseLagrangeHelpers.h.

{
  switch (order)
  {
      // linear Lagrange shape functions
    case libMesh::FIRST:
    {
      switch (type)
      {
        case libMesh::QUAD4:
        case libMesh::QUADSHELL4:
        case libMesh::QUAD8:
        case libMesh::QUADSHELL8:
        case libMesh::QUAD9:
        {
          // Compute quad shape functions as a tensor-product
          const T xi = p(0);
          const T eta = p(1);
 
          libmesh_assert_less(i, 4);
 
          //                                0  1  2  3
          static const unsigned int i0[] = {0, 1, 1, 0};
          static const unsigned int i1[] = {0, 0, 1, 1};
 
          return (fe_lagrange_1D_shape(FIRST, i0[i], xi) * fe_lagrange_1D_shape(FIRST, i1[i], eta));
        }
 
        case libMesh::TRI3:
        case libMesh::TRISHELL3:
        case libMesh::TRI6:
        case libMesh::TRI7:
        {
          const T zeta1 = p(0);
          const T zeta2 = p(1);
          const T zeta0 = 1. - zeta1 - zeta2;
 
          libmesh_assert_less(i, 3);
 
          switch (i)
          {
            case 0:
              return zeta0;
 
            case 1:
              return zeta1;
 
            case 2:
              return zeta2;
 
            default:
              mooseError("Invalid shape function index i = ", i);
          }
        }
 
        default:
          mooseError("Unsupported element type:", type);
      }
    }
 
      // quadratic Lagrange shape functions
    case libMesh::SECOND:
    {
      switch (type)
      {
        case libMesh::QUAD8:
        {
          // Compute quad shape functions as a tensor-product
          const T xi = p(0);
          const T eta = p(1);
 
          libmesh_assert_less(i, 8);
 
          switch (i)
          {
            case 0:
              return .25 * (1. - xi) * (1. - eta) * (-1. - xi - eta);
            case 1:
              return .25 * (1. + xi) * (1. - eta) * (-1. + xi - eta);
            case 2:
              return .25 * (1. + xi) * (eta + 1.) * (-1. + xi + eta);
            case 3:
              return .25 * (1. - xi) * (eta + 1.) * (-1. - xi + eta);
            case 4:
              return .5 * (1. - xi * xi) * (1. - eta);
            case 5:
              return .5 * (1. + xi) * (1. - eta * eta);
            case 6:
              return .5 * (1. - xi * xi) * (1. + eta);
            case 7:
              return .5 * (1. - xi) * (1. - eta * eta);
            default:
              mooseError("Invalid shape function index i = ", i);
          }
        }
        case libMesh::QUAD9:
        {
          // Compute quad shape functions as a tensor-product
          const T xi = p(0);
          const T eta = p(1);
 
          libmesh_assert_less(i, 9);
 
          //                                0  1  2  3  4  5  6  7  8
          static const unsigned int i0[] = {0, 1, 1, 0, 2, 1, 2, 0, 2};
          static const unsigned int i1[] = {0, 0, 1, 1, 0, 2, 1, 2, 2};
 
          return (fe_lagrange_1D_shape(libMesh::SECOND, i0[i], xi) *
                  fe_lagrange_1D_shape(libMesh::SECOND, i1[i], eta));
        }
        case libMesh::TRI6:
        case libMesh::TRI7:
        {
          const T zeta1 = p(0);
          const T zeta2 = p(1);
          const T zeta0 = 1. - zeta1 - zeta2;
 
          libmesh_assert_less(i, 6);
 
          switch (i)
          {
            case 0:
              return 2. * zeta0 * (zeta0 - 0.5);
 
            case 1:
              return 2. * zeta1 * (zeta1 - 0.5);
 
            case 2:
              return 2. * zeta2 * (zeta2 - 0.5);
 
            case 3:
              return 4. * zeta0 * zeta1;
 
            case 4:
              return 4. * zeta1 * zeta2;
 
            case 5:
              return 4. * zeta2 * zeta0;
 
            default:
              mooseError("Invalid shape function index i = ", i);
          }
        }
 
        default:
          mooseError("Unsupported 2D element type");
      }
    }
 
      // "cubic" (one cubic bubble) Lagrange shape functions
    case libMesh::THIRD:
    {
      switch (type)
      {
        case libMesh::TRI7:
        {
          const T zeta1 = p(0);
          const T zeta2 = p(1);
          const T zeta0 = 1. - zeta1 - zeta2;
          const T bubble_27th = zeta0 * zeta1 * zeta2;
 
          libmesh_assert_less(i, 7);
 
          switch (i)
          {
            case 0:
              return 2. * zeta0 * (zeta0 - 0.5) + 3. * bubble_27th;
 
            case 1:
              return 2. * zeta1 * (zeta1 - 0.5) + 3. * bubble_27th;
 
            case 2:
              return 2. * zeta2 * (zeta2 - 0.5) + 3. * bubble_27th;
 
            case 3:
              return 4. * zeta0 * zeta1 - 12. * bubble_27th;
 
            case 4:
              return 4. * zeta1 * zeta2 - 12. * bubble_27th;
 
            case 5:
              return 4. * zeta2 * zeta0 - 12. * bubble_27th;
 
            case 6:
              return 27. * bubble_27th;
 
            default:
              mooseError("Invalid shape function index i = ", i);
          }
        }
 
        default:
          mooseError("Unsupported 2D element type");
      }
    }
 
      // unsupported order
    default:
      mooseError("Unsupported order");
  }
}

Referenced by AutomaticMortarGeneration::getNormals(), and Moose::Mortar::projectQPoints3d().

fe_lagrange_2D_shape_deriv()

template<typename T , template< typename > class VectorType>

T Moose::fe_lagrange_2D_shape_deriv	(	const libMesh::ElemType	type,
		const Order	order,
		const unsigned int	i,
		const unsigned int	j,
		const VectorType< T > &	p
	)

Definition at line 376 of file MooseLagrangeHelpers.h.

{
  libmesh_assert_less(j, 2);
 
  switch (order)
  {
      // linear Lagrange shape functions
    case libMesh::FIRST:
    {
      switch (type)
      {
        case libMesh::QUAD4:
        case libMesh::QUADSHELL4:
        case libMesh::QUAD8:
        case libMesh::QUADSHELL8:
        case libMesh::QUAD9:
        {
          // Compute quad shape functions as a tensor-product
          const T xi = p(0);
          const T eta = p(1);
 
          libmesh_assert_less(i, 4);
 
          //                                0  1  2  3
          static const unsigned int i0[] = {0, 1, 1, 0};
          static const unsigned int i1[] = {0, 0, 1, 1};
 
          switch (j)
          {
              // d()/dxi
            case 0:
              return (fe_lagrange_1D_shape_deriv(FIRST, i0[i], xi) *
                      fe_lagrange_1D_shape(FIRST, i1[i], eta));
 
              // d()/deta
            case 1:
              return (fe_lagrange_1D_shape(FIRST, i0[i], xi) *
                      fe_lagrange_1D_shape_deriv(FIRST, i1[i], eta));
 
            default:
              mooseError("Invalid derivative index j = ", j);
          }
        }
 
        case libMesh::TRI3:
        case libMesh::TRISHELL3:
        case libMesh::TRI6:
        case libMesh::TRI7:
        {
          libmesh_assert_less(i, 3);
 
          const T dzeta0dxi = -1.;
          const T dzeta1dxi = 1.;
          const T dzeta2dxi = 0.;
 
          const T dzeta0deta = -1.;
          const T dzeta1deta = 0.;
          const T dzeta2deta = 1.;
 
          switch (j)
          {
              // d()/dxi
            case 0:
            {
              switch (i)
              {
                case 0:
                  return dzeta0dxi;
 
                case 1:
                  return dzeta1dxi;
 
                case 2:
                  return dzeta2dxi;
 
                default:
                  mooseError("Invalid shape function index i = ", i);
              }
            }
              // d()/deta
            case 1:
            {
              switch (i)
              {
                case 0:
                  return dzeta0deta;
 
                case 1:
                  return dzeta1deta;
 
                case 2:
                  return dzeta2deta;
 
                default:
                  mooseError("Invalid shape function index i = ", i);
              }
            }
            default:
              mooseError("Invalid derivative index j = ", j);
          }
        }
 
        default:
          mooseError("Unsupported 2D element type");
      }
    }
 
      // quadratic Lagrange shape functions
    case libMesh::SECOND:
    {
      switch (type)
      {
        case libMesh::QUAD8:
        case libMesh::QUADSHELL8:
        {
          const T xi = p(0);
          const T eta = p(1);
 
          libmesh_assert_less(i, 8);
 
          switch (j)
          {
              // d/dxi
            case 0:
              switch (i)
              {
                case 0:
                  return .25 * (1. - eta) * ((1. - xi) * (-1.) + (-1.) * (-1. - xi - eta));
 
                case 1:
                  return .25 * (1. - eta) * ((1. + xi) * (1.) + (1.) * (-1. + xi - eta));
 
                case 2:
                  return .25 * (1. + eta) * ((1. + xi) * (1.) + (1.) * (-1. + xi + eta));
 
                case 3:
                  return .25 * (1. + eta) * ((1. - xi) * (-1.) + (-1.) * (-1. - xi + eta));
 
                case 4:
                  return .5 * (-2. * xi) * (1. - eta);
 
                case 5:
                  return .5 * (1.) * (1. - eta * eta);
 
                case 6:
                  return .5 * (-2. * xi) * (1. + eta);
 
                case 7:
                  return .5 * (-1.) * (1. - eta * eta);
 
                default:
                  mooseError("Invalid shape function index i = ", i);
              }
 
              // d/deta
            case 1:
              switch (i)
              {
                case 0:
                  return .25 * (1. - xi) * ((1. - eta) * (-1.) + (-1.) * (-1. - xi - eta));
 
                case 1:
                  return .25 * (1. + xi) * ((1. - eta) * (-1.) + (-1.) * (-1. + xi - eta));
 
                case 2:
                  return .25 * (1. + xi) * ((1. + eta) * (1.) + (1.) * (-1. + xi + eta));
 
                case 3:
                  return .25 * (1. - xi) * ((1. + eta) * (1.) + (1.) * (-1. - xi + eta));
 
                case 4:
                  return .5 * (1. - xi * xi) * (-1.);
 
                case 5:
                  return .5 * (1. + xi) * (-2. * eta);
 
                case 6:
                  return .5 * (1. - xi * xi) * (1.);
 
                case 7:
                  return .5 * (1. - xi) * (-2. * eta);
 
                default:
                  mooseError("Invalid shape function index i = ", i);
              }
 
            default:
              mooseError("ERROR: Invalid derivative index j = ", j);
          }
        }
 
        case libMesh::QUAD9:
        {
          // Compute quad shape functions as a tensor-product
          const T xi = p(0);
          const T eta = p(1);
 
          libmesh_assert_less(i, 9);
 
          //                                0  1  2  3  4  5  6  7  8
          static const unsigned int i0[] = {0, 1, 1, 0, 2, 1, 2, 0, 2};
          static const unsigned int i1[] = {0, 0, 1, 1, 0, 2, 1, 2, 2};
 
          switch (j)
          {
              // d()/dxi
            case 0:
              return (fe_lagrange_1D_shape_deriv(libMesh::SECOND, i0[i], xi) *
                      fe_lagrange_1D_shape(libMesh::SECOND, i1[i], eta));
 
              // d()/deta
            case 1:
              return (fe_lagrange_1D_shape(libMesh::SECOND, i0[i], xi) *
                      fe_lagrange_1D_shape_deriv(libMesh::SECOND, i1[i], eta));
 
            default:
              mooseError("Invalid derivative index j = ", j);
          }
        }
 
        case libMesh::TRI6:
        case libMesh::TRI7:
        {
          libmesh_assert_less(i, 6);
 
          const T zeta1 = p(0);
          const T zeta2 = p(1);
          const T zeta0 = 1. - zeta1 - zeta2;
 
          const T dzeta0dxi = -1.;
          const T dzeta1dxi = 1.;
          const T dzeta2dxi = 0.;
 
          const T dzeta0deta = -1.;
          const T dzeta1deta = 0.;
          const T dzeta2deta = 1.;
 
          switch (j)
          {
            case 0:
            {
              switch (i)
              {
                case 0:
                  return (4. * zeta0 - 1.) * dzeta0dxi;
 
                case 1:
                  return (4. * zeta1 - 1.) * dzeta1dxi;
 
                case 2:
                  return (4. * zeta2 - 1.) * dzeta2dxi;
 
                case 3:
                  return 4. * zeta1 * dzeta0dxi + 4. * zeta0 * dzeta1dxi;
 
                case 4:
                  return 4. * zeta2 * dzeta1dxi + 4. * zeta1 * dzeta2dxi;
 
                case 5:
                  return 4. * zeta2 * dzeta0dxi + 4 * zeta0 * dzeta2dxi;
 
                default:
                  mooseError("Invalid shape function index i = ", i);
              }
            }
 
            case 1:
            {
              switch (i)
              {
                case 0:
                  return (4. * zeta0 - 1.) * dzeta0deta;
 
                case 1:
                  return (4. * zeta1 - 1.) * dzeta1deta;
 
                case 2:
                  return (4. * zeta2 - 1.) * dzeta2deta;
 
                case 3:
                  return 4. * zeta1 * dzeta0deta + 4. * zeta0 * dzeta1deta;
 
                case 4:
                  return 4. * zeta2 * dzeta1deta + 4. * zeta1 * dzeta2deta;
 
                case 5:
                  return 4. * zeta2 * dzeta0deta + 4 * zeta0 * dzeta2deta;
 
                default:
                  mooseError("Invalid shape function index i = ", i);
              }
            }
            default:
              mooseError("ERROR: Invalid derivative index j = ", j);
          }
        }
 
        default:
          mooseError("ERROR: Unsupported 2D element type");
      }
    }
 
      // "cubic" (one cubic bubble) Lagrange shape functions
    case libMesh::THIRD:
    {
      switch (type)
      {
        case libMesh::TRI7:
        {
          libmesh_assert_less(i, 7);
 
          const T zeta1 = p(0);
          const T zeta2 = p(1);
          const T zeta0 = 1. - zeta1 - zeta2;
 
          const T dzeta0dxi = -1.;
          const T dzeta1dxi = 1.;
          const T dzeta2dxi = 0.;
          const T dbubbledxi = zeta2 * (1. - 2. * zeta1 - zeta2);
 
          const T dzeta0deta = -1.;
          const T dzeta1deta = 0.;
          const T dzeta2deta = 1.;
          const T dbubbledeta = zeta1 * (1. - zeta1 - 2. * zeta2);
 
          switch (j)
          {
            case 0:
            {
              switch (i)
              {
                case 0:
                  return (4. * zeta0 - 1.) * dzeta0dxi + 3. * dbubbledxi;
 
                case 1:
                  return (4. * zeta1 - 1.) * dzeta1dxi + 3. * dbubbledxi;
 
                case 2:
                  return (4. * zeta2 - 1.) * dzeta2dxi + 3. * dbubbledxi;
 
                case 3:
                  return 4. * zeta1 * dzeta0dxi + 4. * zeta0 * dzeta1dxi - 12. * dbubbledxi;
 
                case 4:
                  return 4. * zeta2 * dzeta1dxi + 4. * zeta1 * dzeta2dxi - 12. * dbubbledxi;
 
                case 5:
                  return 4. * zeta2 * dzeta0dxi + 4 * zeta0 * dzeta2dxi - 12. * dbubbledxi;
 
                case 6:
                  return 27. * dbubbledxi;
 
                default:
                  mooseError("Invalid shape function index i = ", i);
              }
            }
 
            case 1:
            {
              switch (i)
              {
                case 0:
                  return (4. * zeta0 - 1.) * dzeta0deta + 3. * dbubbledeta;
 
                case 1:
                  return (4. * zeta1 - 1.) * dzeta1deta + 3. * dbubbledeta;
 
                case 2:
                  return (4. * zeta2 - 1.) * dzeta2deta + 3. * dbubbledeta;
 
                case 3:
                  return 4. * zeta1 * dzeta0deta + 4. * zeta0 * dzeta1deta - 12. * dbubbledeta;
 
                case 4:
                  return 4. * zeta2 * dzeta1deta + 4. * zeta1 * dzeta2deta - 12. * dbubbledeta;
 
                case 5:
                  return 4. * zeta2 * dzeta0deta + 4 * zeta0 * dzeta2deta - 12. * dbubbledeta;
 
                case 6:
                  return 27. * dbubbledeta;
 
                default:
                  mooseError("Invalid shape function index i = ", i);
              }
            }
            default:
              mooseError("ERROR: Invalid derivative index j = ", j);
          }
        }
 
        default:
          mooseError("ERROR: Unsupported 2D element type");
      }
    }
 
      // unsupported order
    default:
      mooseError("Unsupported order");
  }
}

findContactPoint() [1/2]

void Moose::findContactPoint	(	PenetrationInfo &	p_info,
		FEBase *	fe_elem,
		FEBase *	fe_side,
		FEType &	,
		const libMesh::Point &	secondary_point,
		bool	start_with_centroid,
		const Real	tangential_tolerance,
		bool &	contact_point_on_side,
		bool &	search_succeeded
	)

Finds the closest point (called the contact point) on the primary_elem on side "side" to the secondary_point.

Parameters

p_info	The penetration info object, contains primary_elem, side, various other information
fe_elem	FE object for the element
fe_side	FE object for the side
fe_side_type	Unused; was used for a now-deprecated inverse_map overload.
start_with_centroid	if true, start inverse mapping procedure from element centroid
tangential_tolerance	'tangential' tolerance for determining whether a contact point on a side
secondary_point	The physical space coordinates of the secondary node
contact_point_on_side	whether or not the contact_point actually lies on that side of the element.
search_succeeded	whether or not the search for the contact point succeeded. If not it should likely be discarded

Definition at line 51 of file FindContactPoint.C.

{
  // Default to true and we'll switch on failures
  search_succeeded = true;
 
  const Elem * primary_elem = p_info._elem;
 
  unsigned int dim = primary_elem->dim();
 
  const Elem * side = p_info._side;
 
  const std::vector<libMesh::Point> & phys_point = fe_side->get_xyz();
 
  const std::vector<RealGradient> & dxyz_dxi = fe_side->get_dxyzdxi();
  const std::vector<RealGradient> & d2xyz_dxi2 = fe_side->get_d2xyzdxi2();
  const std::vector<RealGradient> & d2xyz_dxieta = fe_side->get_d2xyzdxideta();
 
  const std::vector<RealGradient> & dxyz_deta = fe_side->get_dxyzdeta();
  const std::vector<RealGradient> & d2xyz_deta2 = fe_side->get_d2xyzdeta2();
  const std::vector<RealGradient> & d2xyz_detaxi = fe_side->get_d2xyzdxideta();
 
  if (dim == 1)
  {
    const Node * nearest_node = side->node_ptr(0);
    p_info._closest_point = *nearest_node;
    p_info._closest_point_ref =
        primary_elem->master_point(primary_elem->get_node_index(nearest_node));
    std::vector<libMesh::Point> elem_points = {p_info._closest_point_ref};
 
    const std::vector<RealGradient> & elem_dxyz_dxi = fe_elem->get_dxyzdxi();
 
    fe_elem->reinit(primary_elem, &elem_points);
    fe_side->reinit(side, &elem_points);
 
    p_info._normal = elem_dxyz_dxi[0];
    if (nearest_node->id() == primary_elem->node_id(0))
      p_info._normal *= -1.0;
    p_info._normal /= p_info._normal.norm();
 
    libMesh::Point from_secondary_to_closest = p_info._closest_point - secondary_point;
    p_info._distance = from_secondary_to_closest * p_info._normal;
    libMesh::Point tangential = from_secondary_to_closest - p_info._distance * p_info._normal;
    p_info._tangential_distance = tangential.norm();
    p_info._dxyzdxi = dxyz_dxi;
    p_info._dxyzdeta = dxyz_deta;
    p_info._d2xyzdxideta = d2xyz_dxieta;
    p_info._side_phi = fe_side->get_phi();
    p_info._side_grad_phi = fe_side->get_dphi();
    contact_point_on_side = true;
    return;
  }
 
  libMesh::Point ref_point;
 
  if (start_with_centroid)
    ref_point = FEMap::inverse_map(dim - 1, side, side->vertex_average(), TOLERANCE, false);
  else
    ref_point = p_info._closest_point_ref;
 
  std::vector<libMesh::Point> points = {ref_point};
  fe_side->reinit(side, &points);
  RealGradient d = secondary_point - phys_point[0];
 
  Real update_size = std::numeric_limits<Real>::max();
 
  // Least squares
  for (unsigned int it = 0; it < 3 && update_size > TOLERANCE * 1e3; ++it)
  {
    DenseMatrix<Real> jac(dim - 1, dim - 1);
    jac(0, 0) = -(dxyz_dxi[0] * dxyz_dxi[0]);
 
    if (dim - 1 == 2)
    {
      jac(1, 0) = -(dxyz_dxi[0] * dxyz_deta[0]);
      jac(0, 1) = -(dxyz_deta[0] * dxyz_dxi[0]);
      jac(1, 1) = -(dxyz_deta[0] * dxyz_deta[0]);
    }
 
    DenseVector<Real> rhs(dim - 1);
    rhs(0) = dxyz_dxi[0] * d;
 
    if (dim - 1 == 2)
      rhs(1) = dxyz_deta[0] * d;
 
    DenseVector<Real> update(dim - 1);
    jac.lu_solve(rhs, update);
 
    ref_point(0) -= update(0);
 
    if (dim - 1 == 2)
      ref_point(1) -= update(1);
 
    points[0] = ref_point;
    fe_side->reinit(side, &points);
    d = secondary_point - phys_point[0];
 
    update_size = update.l2_norm();
  }
 
  update_size = std::numeric_limits<Real>::max();
 
  unsigned nit = 0;
 
  // Newton Loop
  const auto max_newton_its = 25;
  const auto tolerance_newton = 1e3 * TOLERANCE * TOLERANCE;
  for (; nit < max_newton_its && update_size > tolerance_newton; nit++)
  {
    d = secondary_point - phys_point[0];
 
    DenseMatrix<Real> jac(dim - 1, dim - 1);
    jac(0, 0) = (d2xyz_dxi2[0] * d) - (dxyz_dxi[0] * dxyz_dxi[0]);
 
    if (dim - 1 == 2)
    {
      jac(1, 0) = (d2xyz_dxieta[0] * d) - (dxyz_dxi[0] * dxyz_deta[0]);
 
      jac(0, 1) = (d2xyz_detaxi[0] * d) - (dxyz_deta[0] * dxyz_dxi[0]);
      jac(1, 1) = (d2xyz_deta2[0] * d) - (dxyz_deta[0] * dxyz_deta[0]);
    }
 
    DenseVector<Real> rhs(dim - 1);
    rhs(0) = -dxyz_dxi[0] * d;
 
    if (dim - 1 == 2)
      rhs(1) = -dxyz_deta[0] * d;
 
    DenseVector<Real> update(dim - 1);
    jac.lu_solve(rhs, update);
 
    // Improvised line search in case the update is too large and gets out of the element so bad
    // that we cannot reinit at the new point
    Real mult = 1;
    while (true)
    {
      try
      {
        ref_point(0) += mult * update(0);
 
        if (dim - 1 == 2)
          ref_point(1) += mult * update(1);
 
        points[0] = ref_point;
        fe_side->reinit(side, &points);
        d = secondary_point - phys_point[0];
 
        // we don't multiply by 'mult' because it is used for convergence
        update_size = update.l2_norm();
        break;
      }
      // libMesh might throw here if we hit a zero/negative Jacobian
      catch (std::exception & e)
      {
        // Make sure this *is* just a bad mapping Jacobian
        if (!strstr(e.what(), "Jacobian") && !strstr(e.what(), "det != 0"))
          throw;
 
        ref_point(0) -= mult * update(0);
        if (dim - 1 == 2)
          ref_point(1) -= mult * update(1);
 
        mult *= 0.5;
        if (mult < 1e-6)
        {
#ifndef NDEBUG
          mooseWarning("We could not solve for the contact point.", e.what());
#endif
          update_size = update.l2_norm();
          d = (secondary_point - phys_point[0]) * mult;
          break;
        }
      }
    }
    // We failed the line search, make sure to trigger the error
    if (mult < 1e-6)
    {
      nit = max_newton_its;
      update_size = 1;
      break;
    }
  }
 
  if (nit == max_newton_its && update_size > tolerance_newton)
  {
    search_succeeded = false;
#ifndef NDEBUG
    const auto initial_point =
        start_with_centroid ? side->vertex_average() : ref_point = p_info._closest_point_ref;
    Moose::err << "Warning!  Newton solve for contact point failed to converge!\nLast update "
                  "distance was: "
               << update_size << "\nInitial point guess:   " << initial_point
               << "\nLast considered point: " << phys_point[0]
               << "\nThis potential contact pair (face, point) will be discarded." << std::endl;
#endif
    return;
  }
 
  p_info._closest_point_ref = ref_point;
  p_info._closest_point = phys_point[0];
  p_info._distance = d.norm();
 
  if (dim - 1 == 2)
  {
    p_info._normal = dxyz_dxi[0].cross(dxyz_deta[0]);
    if (!MooseUtils::absoluteFuzzyEqual(p_info._normal.norm(), 0))
      p_info._normal /= p_info._normal.norm();
  }
  else
  {
    const Node * const * elem_nodes = primary_elem->get_nodes();
    const libMesh::Point in_plane_vector1 = *elem_nodes[1] - *elem_nodes[0];
    const libMesh::Point in_plane_vector2 = *elem_nodes[2] - *elem_nodes[0];
 
    libMesh::Point out_of_plane_normal = in_plane_vector1.cross(in_plane_vector2);
    out_of_plane_normal /= out_of_plane_normal.norm();
 
    p_info._normal = dxyz_dxi[0].cross(out_of_plane_normal);
    if (std::fabs(p_info._normal.norm()) > 1e-15)
      p_info._normal /= p_info._normal.norm();
  }
 
  // If the point has not penetrated the face, make the distance negative
  const Real dot(d * p_info._normal);
  if (dot > 0.0)
    p_info._distance = -p_info._distance;
 
  contact_point_on_side = side->on_reference_element(ref_point);
 
  p_info._tangential_distance = 0.0;
 
  if (!contact_point_on_side)
  {
    p_info._closest_point_on_face_ref = ref_point;
    restrictPointToFace(p_info._closest_point_on_face_ref, side, p_info._off_edge_nodes);
 
    points[0] = p_info._closest_point_on_face_ref;
    fe_side->reinit(side, &points);
    libMesh::Point closest_point_on_face(phys_point[0]);
 
    RealGradient off_face = closest_point_on_face - p_info._closest_point;
    Real tangential_distance = off_face.norm();
    p_info._tangential_distance = tangential_distance;
    if (tangential_distance <= tangential_tolerance)
    {
      contact_point_on_side = true;
    }
  }
 
  const std::vector<std::vector<Real>> & phi = fe_side->get_phi();
  const std::vector<std::vector<RealGradient>> & grad_phi = fe_side->get_dphi();
 
  points[0] = p_info._closest_point_ref;
  fe_side->reinit(side, &points);
 
  p_info._side_phi = phi;
  p_info._side_grad_phi = grad_phi;
  p_info._dxyzdxi = dxyz_dxi;
  p_info._dxyzdeta = dxyz_deta;
  p_info._d2xyzdxideta = d2xyz_dxieta;
}

findContactPoint() [2/2]

void Moose::findContactPoint	(	PenetrationInfo &	p_info,
		libMesh::FEBase *	fe_elem,
		libMesh::FEBase *	fe_side,
		libMesh::FEType &	fe_side_type,
		const libMesh::Point &	secondary_point,
		bool	start_with_centroid,
		const Real	tangential_tolerance,
		bool &	contact_point_on_side,
		bool &	search_succeeded
	)

Referenced by PenetrationThread::createInfoForElem(), and PenetrationThread::operator()().

findElementsIntersectedByPlane()

void Moose::findElementsIntersectedByPlane	(	const libMesh::Plane &	plane,
		const MeshBase &	mesh,
		std::vector< const Elem * > &	intersected_elems
	)

Definition at line 24 of file ElementsIntersectedByPlane.C.

{
  // Loop over all elements to find elements intersected by the plane
  for (const auto & elem : mesh.element_ptr_range())
  {
    bool intersected = false;
 
    // Check whether the first node of this element is below or above the plane
    const Node & node0 = elem->node_ref(0);
    bool node0_above_plane = plane.above_surface(node0);
 
    // Loop over the rest of the nodes and check if any node is on the other side of the plane
    for (unsigned int i = 1; i < elem->n_nodes(); ++i)
    {
      const Node & node = elem->node_ref(i);
 
      bool node_above_plane = plane.above_surface(node);
      if (node0_above_plane != node_above_plane)
        intersected = true;
    }
 
    if (intersected)
      intersected_elems.push_back(elem);
  }
}

Referenced by elementsIntersectedByPlane(), and elementsIntersectedByPlane().

findSimilar()

std::vector< std::string > Moose::findSimilar	(	const std::string &	param,
		const std::vector< std::string > &	options
	)

Definition at line 80 of file Builder.C.

{
  std::vector<std::string> candidates;
  if (options.size() == 0)
    return candidates;
 
  int mindist = MooseUtils::levenshteinDist(options[0], param);
  for (const auto & opt : options)
  {
    const int dist = MooseUtils::levenshteinDist(opt, param);
    // magic number heuristics to get similarity distance cutoff
    const int dist_cutoff = 1 + param.size() / 5;
    if (dist > dist_cutoff || dist > mindist)
      continue;
 
    if (dist < mindist)
    {
      mindist = dist;
      candidates.clear();
    }
    candidates.push_back(opt);
  }
  return candidates;
}

Referenced by Moose::UnusedWalker::walk().

getExec()

std::string Moose::getExec

(

)

Gets the full path to the running executable on Mac OS X and linux.

Not implemented for windows.

Definition at line 24 of file ExecutablePath.C.

{
  std::string exec_path;
  char path[1024];
 
#if defined(__APPLE__)
  uint32_t size = sizeof(path);
  if (_NSGetExecutablePath(path, &size) == 0)
    exec_path = path;
  else
    mooseError("Unable to retrieve executable path");
#elif defined(__WIN32__)
  return "./";
#else // Linux with Proc
  std::ostringstream oss;
  oss << "/proc/" << getpid() << "/exe";
  int ch = readlink(oss.str().c_str(), path, 1024);
  if (ch != -1)
  {
    path[ch] = 0;
    exec_path = path;
  }
#endif
  return exec_path;
}

Referenced by SystemInfo::getExecutable(), getExecutableName(), getExecutablePath(), and Moose::internal::Capabilities::registerMooseCapabilities().

getExecutableName()

std::string Moose::getExecutableName

(

)

Gets the name of the running executable on Mac OS X and linux.

Not implemented for windows.

Definition at line 60 of file ExecutablePath.C.

{
  auto name = getExec();
  // strip off the path to get the name
  std::string::size_type start = name.find_last_of("/");
  if (start == std::string::npos)
    start = 0;
  return name.substr(start, std::string::npos);
}

Referenced by MooseApp::appBinaryName(), and MooseApp::runInputs().

getExecutablePath()

std::string Moose::getExecutablePath

(

)

Gets the directory the running executable is on Mac OS X and linux.

Not implemented for windows.

Definition at line 51 of file ExecutablePath.C.

{
  auto exec_path = getExec();
  // strip off the exeuctable to get the PATH
  std::string::size_type t = exec_path.find_last_of("/");
  return exec_path.substr(0, t) + "/";
}

Referenced by Registry::determineDataFilePath(), MooseUtils::docsDir(), MooseUtils::installedInputsDir(), ADFParser::JITCompile(), and MooseUtils::runTestsExecutable().

globalADIndexing()

bool Moose::globalADIndexing ( )

inline

Whether we are using global AD indexing.

Definition at line 28 of file ADUtils.h.

{
  return true;
}

Referenced by FEProblemBase::init().

globalDofIndexToDerivative() [1/2]

std::unordered_map< dof_id_type, Real > Moose::globalDofIndexToDerivative	(	const ADReal &	ad_real,
		const SystemBase &	sys,
		ElementType	elem_type = ElementType::Element,
		THREAD_ID	tid = 0
	)

Generate a map from global dof index to derivative value.

Definition at line 27 of file ADUtils.C.

{
  mooseAssert(dynamic_cast<const NonlinearSystemBase *>(&sys),
              "This must be a nonlinear system base object");
  const Assembly & assembly = sys.subproblem().assembly(tid, sys.number());
  const Elem * elem;
  switch (elem_type)
  {
    case ElementType::Element:
      elem = assembly.elem();
      break;
 
    case ElementType::Neighbor:
      elem = assembly.neighbor();
      break;
 
    case ElementType::Lower:
      elem = assembly.lowerDElem();
      break;
 
    default:
      mooseError("Unrecognized element type");
  }
 
  std::unordered_map<dof_id_type, Real> ret_val;
 
  const System & libmesh_sys = sys.system();
  const DofMap & dof_map = libmesh_sys.get_dof_map();
 
  const unsigned int num_vars = libmesh_sys.n_vars();
 
  const auto max_dofs_per_elem = sys.getMaxVarNDofsPerElem();
 
  for (unsigned int var_num = 0; var_num < num_vars; ++var_num)
  {
    std::vector<dof_id_type> global_indices;
 
    // Get the global indices corresponding to var_num that exist on elem
    dof_map.dof_indices(elem, global_indices, var_num);
 
    // determine the AD offset for the current var
    const auto ad_offset = adOffset(var_num, max_dofs_per_elem, elem_type, num_vars);
 
    // Map from global index to derivative
    for (MooseIndex(global_indices) local_index = 0; local_index < global_indices.size();
         ++local_index)
      ret_val[global_indices[local_index]] = ad_real.derivatives()[ad_offset + local_index];
  }
 
  return ret_val;
}

Referenced by globalDofIndexToDerivative().

globalDofIndexToDerivative() [2/2]

template<typename T >

auto Moose::globalDofIndexToDerivative	(	const T &	ad_real_container,
		const SystemBase &	sys,
		ElementType	elem_type = ElementType::Element,
		THREAD_ID	tid = 0
	)		-> std::vector<std::unordered_map< dof_id_type, typename std::enable_if<std::is_same<ADReal, typename T::value_type>::value, Real>::type>>

Generate a map from global dof index to derivative value for a (probably quadrature-point-based) container like a material property or a variable value.

Definition at line 135 of file ADUtils.h.

{
  std::vector<std::unordered_map<dof_id_type, Real>> ret_val(ad_real_container.size());
 
  for (MooseIndex(ad_real_container) i = 0; i < ad_real_container.size(); ++i)
    ret_val[i] = globalDofIndexToDerivative(ad_real_container[i], sys, elem_type, tid);
 
  return ret_val;
}

hash_combine() [1/4]

void Moose::hash_combine ( std::size_t &  )

inline

Used for hash function specialization for Attribute objects.

Definition at line 22 of file MooseHashing.h.

{
}

Referenced by hash_combine(), hash_combine(), hash_combine(), std::hash< Attribute >::operator()(), PointIndexedMap::hash_point::operator()(), moose::internal::SoltionInvalidityNameHash::operator()(), std::hash< std::pair< S, T > >::operator()(), and std::hash< std::vector< std::unique_ptr< Attribute > > >::operator()().

hash_combine() [2/4]

template<typename T , typename... Rest>

void Moose::hash_combine ( std::size_t &  seed, const std::set< T > &  v, Rest &&...  rest  )

inline

Used for hash function specialization for Attribute objects.

Definition at line 50 of file MooseHashing.h.

{
  for (auto & val : v)
    hash_combine(seed, val);
  hash_combine(seed, std::forward<Rest>(rest)...);
}

hash_combine() [3/4]

template<typename T , typename... Rest>

void Moose::hash_combine ( std::size_t &  seed, const std::vector< T > &  v, Rest &&...  rest  )

inline

Used for hash function specialization for Attribute objects.

Definition at line 40 of file MooseHashing.h.

{
  for (auto & val : v)
    hash_combine(seed, val);
  hash_combine(seed, std::forward<Rest>(rest)...);
}

hash_combine() [4/4]

template<typename T , typename... Rest>

void Moose::hash_combine ( std::size_t &  seed, const T &  v, Rest &&...  rest  )

inline

Used to combine an existing hash value with the hash of one or more other values (v and rest).

For example "auto h = std::hash("hello"); hash_combine(h, my_int_val, my_float_val, etc.);"

Definition at line 30 of file MooseHashing.h.

{
  std::hash<T> hasher;
  seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
  hash_combine(seed, std::forward<Rest>(rest)...);
}

hitMessagePrefix()

std::string Moose::hitMessagePrefix

(

const hit::Node &

node

)

Get the prefix to be associated with a hit node for a message.

Definition at line 909 of file Moose.C.

  : _throw_on_error_before(Moose::_throw_on_error)
{
  mooseAssert(!libMesh::Threads::in_threads, "Cannot be used in threads");
  Moose::_throw_on_error = throw_on_error;
}
 

Referenced by MooseBase::messagePrefix(), moose::internal::mooseErrorRaw(), and InputParameters::paramMessagePrefix().

indirectSort() [1/2]

template<class RandomAccessIterator >

void Moose::indirectSort	(	RandomAccessIterator	beg,
		RandomAccessIterator	end,
		std::vector< size_t > &	b
	)

Definition at line 68 of file IndirectSort.h.

{
  // Space in b
  initialize_indirect_sort(beg, end, b);
 
  // Typedef for less typing.  Note: use of std::iterator_traits means this should work with
  // naked pointers too...
  typedef std::less<typename std::iterator_traits<RandomAccessIterator>::value_type>
      LessThanComparator;
 
  // Construct comparator object
  indirect_comparator<RandomAccessIterator, LessThanComparator> ic(beg, LessThanComparator());
 
  // Sort the indices, based on the data
  //
  // Many use cases pass in a partial order, not a total order; use
  // stable_sort to make the results of that as reproduceable as
  // possible.
  std::stable_sort(b.begin(), b.end(), ic);
}

Referenced by SamplerBase::finalize(), and PerfGraph::printHeaviestSections().

indirectSort() [2/2]

template<class RandomAccessIterator , class UserComparisonFunctor >

void Moose::indirectSort	(	RandomAccessIterator	beg,
		RandomAccessIterator	end,
		std::vector< size_t > &	b,
		UserComparisonFunctor	user_comp
	)

Definition at line 93 of file IndirectSort.h.

{
  // Space in b
  initialize_indirect_sort(beg, end, b);
 
  // Construct comparator object
  indirect_comparator<RandomAccessIterator, UserComparisonFunctor> ic(beg, user_comp);
 
  // Sort the indices, based on the data
  //
  // Many use cases pass in a partial order, not a total order; use
  // stable_sort to make the results of that as reproduceable as
  // possible.
  std::stable_sort(b.begin(), b.end(), ic);
}

initCoordinateSystemType()

void Moose::initCoordinateSystemType

(

)

Definition at line 35 of file Conversion.C.

{
  if (coordinate_system_type_to_enum.empty())
  {
    coordinate_system_type_to_enum["XYZ"] = COORD_XYZ;
    coordinate_system_type_to_enum["RZ"] = COORD_RZ;
    coordinate_system_type_to_enum["RSPHERICAL"] = COORD_RSPHERICAL;
  }
}

Referenced by stringToEnum< CoordinateSystemType >().

initDofIndices()

template<typename T >

void Moose::initDofIndices	(	T &	data,
		const Elem &	elem
	)

Definition at line 47 of file MooseVariableDataFV.h.

{
  if (data._prev_elem != &elem)
  {
    data._dof_map.dof_indices(&elem, data._dof_indices, data._var_num);
    data._prev_elem = &elem;
  }
}

Referenced by MooseVariableFV< OutputType >::getValue(), MooseVariableDataFV< OutputType >::initDofIndices(), and MooseVariableDataLinearFV< OutputType >::initDofIndices().

initEigenProlemType()

void Moose::initEigenProlemType

(

)

Definition at line 76 of file Conversion.C.

{
  if (eigen_problem_type_to_enum.empty())
  {
    eigen_problem_type_to_enum["HERMITIAN"] = EPT_HERMITIAN;
    eigen_problem_type_to_enum["NON_HERMITIAN"] = EPT_NON_HERMITIAN;
    eigen_problem_type_to_enum["GEN_HERMITIAN"] = EPT_GEN_HERMITIAN;
    eigen_problem_type_to_enum["GEN_NON_HERMITIAN"] = EPT_GEN_NON_HERMITIAN;
    eigen_problem_type_to_enum["GEN_INDEFINITE"] = EPT_GEN_INDEFINITE;
    eigen_problem_type_to_enum["POS_GEN_NON_HERMITIAN"] = EPT_POS_GEN_NON_HERMITIAN;
    eigen_problem_type_to_enum["SLEPC_DEFAULT"] = EPT_SLEPC_DEFAULT;
  }
}

Referenced by stringToEnum< EigenProblemType >().

initEigenSolveType()

void Moose::initEigenSolveType

(

)

Definition at line 59 of file Conversion.C.

{
  if (eigen_solve_type_to_enum.empty())
  {
    eigen_solve_type_to_enum["POWER"] = EST_POWER;
    eigen_solve_type_to_enum["ARNOLDI"] = EST_ARNOLDI;
    eigen_solve_type_to_enum["KRYLOVSCHUR"] = EST_KRYLOVSCHUR;
    eigen_solve_type_to_enum["JACOBI_DAVIDSON"] = EST_JACOBI_DAVIDSON;
    eigen_solve_type_to_enum["NONLINEAR_POWER"] = EST_NONLINEAR_POWER;
    eigen_solve_type_to_enum["NEWTON"] = EST_NEWTON;
    eigen_solve_type_to_enum["PJFNK"] = EST_PJFNK;
    eigen_solve_type_to_enum["PJFNKMO"] = EST_PJFNKMO;
    eigen_solve_type_to_enum["JFNK"] = EST_JFNK;
  }
}

Referenced by stringToEnum< EigenSolveType >().

initial_condition()

void Moose::initial_condition ( libMesh::EquationSystems &  es, const std::string &  system_name  )

private

initialize_indirect_sort()

template<class RandomAccessIterator >

void Moose::initialize_indirect_sort	(	RandomAccessIterator	beg,
		RandomAccessIterator	end,
		std::vector< size_t > &	b
	)

Definition at line 52 of file IndirectSort.h.

{
  // enough storage for all the indices
  b.resize(std::distance(beg, end));
 
  // iota
  for (size_t i = 0; i < b.size(); ++i)
    b[i] = i;
}

Referenced by indirectSort(), and indirectSort().

initLineSearchType()

void Moose::initLineSearchType

(

)

Definition at line 110 of file Conversion.C.

{
  if (line_search_type_to_enum.empty())
  {
    line_search_type_to_enum["DEFAULT"] = LS_DEFAULT;
    line_search_type_to_enum["NONE"] = LS_NONE;
    line_search_type_to_enum["BASIC"] = LS_BASIC;
 
    line_search_type_to_enum["SHELL"] = LS_SHELL;
    line_search_type_to_enum["L2"] = LS_L2;
    line_search_type_to_enum["BT"] = LS_BT;
    line_search_type_to_enum["CP"] = LS_CP;
    line_search_type_to_enum["CONTACT"] = LS_CONTACT;
    line_search_type_to_enum["PROJECT"] = LS_PROJECT;
  }
}

Referenced by stringToEnum< LineSearchType >().

initMffdType()

void Moose::initMffdType

(

)

Definition at line 143 of file Conversion.C.

{
  if (mffd_type_to_enum.empty())
  {
    mffd_type_to_enum["DS"] = MFFD_DS;
    mffd_type_to_enum["WP"] = MFFD_WP;
  }
}

Referenced by stringToEnum< MffdType >().

initRMType()

void Moose::initRMType

(

)

Definition at line 153 of file Conversion.C.

{
  if (rm_type_to_enum.empty())
  {
    rm_type_to_enum["DEFAULT"] = RelationshipManagerType::DEFAULT;
    rm_type_to_enum["GEOMETRIC"] = RelationshipManagerType::GEOMETRIC;
    rm_type_to_enum["ALGEBRAIC"] = RelationshipManagerType::ALGEBRAIC;
    rm_type_to_enum["COUPLING"] = RelationshipManagerType::COUPLING;
  }
}

Referenced by stringToEnum< RelationshipManagerType >().

initSolveType()

void Moose::initSolveType

(

)

Definition at line 46 of file Conversion.C.

{
  if (solve_type_to_enum.empty())
  {
    solve_type_to_enum["PJFNK"] = ST_PJFNK;
    solve_type_to_enum["JFNK"] = ST_JFNK;
    solve_type_to_enum["NEWTON"] = ST_NEWTON;
    solve_type_to_enum["FD"] = ST_FD;
    solve_type_to_enum["LINEAR"] = ST_LINEAR;
  }
}

Referenced by stringToEnum< SolveType >().

initTimeIntegratorsType()

void Moose::initTimeIntegratorsType

(

)

Definition at line 128 of file Conversion.C.

{
  if (time_integrator_to_enum.empty())
  {
    time_integrator_to_enum["IMPLICIT_EULER"] = TI_IMPLICIT_EULER;
    time_integrator_to_enum["EXPLICIT_EULER"] = TI_EXPLICIT_EULER;
    time_integrator_to_enum["CRANK_NICOLSON"] = TI_CRANK_NICOLSON;
    time_integrator_to_enum["BDF2"] = TI_BDF2;
    time_integrator_to_enum["EXPLICIT_MIDPOINT"] = TI_EXPLICIT_MIDPOINT;
    time_integrator_to_enum["LSTABLE_DIRK2"] = TI_LSTABLE_DIRK2;
    time_integrator_to_enum["EXPLICIT_TVDRK2"] = TI_EXPLICIT_TVD_RK_2;
  }
}

Referenced by stringToEnum< TimeIntegratorType >().

initWhichEigenPairs()

void Moose::initWhichEigenPairs

(

)

Definition at line 91 of file Conversion.C.

{
  if (which_eigen_pairs_to_enum.empty())
  {
    which_eigen_pairs_to_enum["LARGEST_MAGNITUDE"] = WEP_LARGEST_MAGNITUDE;
    which_eigen_pairs_to_enum["SMALLEST_MAGNITUDE"] = WEP_SMALLEST_MAGNITUDE;
    which_eigen_pairs_to_enum["LARGEST_REAL"] = WEP_LARGEST_REAL;
    which_eigen_pairs_to_enum["SMALLEST_REAL"] = WEP_SMALLEST_REAL;
    which_eigen_pairs_to_enum["LARGEST_IMAGINARY"] = WEP_LARGEST_IMAGINARY;
    which_eigen_pairs_to_enum["SMALLEST_IMAGINARY"] = WEP_SMALLEST_IMAGINARY;
    which_eigen_pairs_to_enum["TARGET_MAGNITUDE"] = WEP_TARGET_MAGNITUDE;
    which_eigen_pairs_to_enum["TARGET_REAL"] = WEP_TARGET_REAL;
    which_eigen_pairs_to_enum["TARGET_IMAGINARY"] = WEP_TARGET_IMAGINARY;
    which_eigen_pairs_to_enum["ALL_EIGENVALUES"] = WEP_ALL_EIGENVALUES;
    which_eigen_pairs_to_enum["SLEPC_DEFAULT"] = WEP_SLEPC_DEFAULT;
  }
}

Referenced by stringToEnum< WhichEigenPairs >().

isSectionActive()

bool Moose::isSectionActive

(

const hit::Node &

node

)

Definition at line 45 of file Builder.C.

{
  const hit::Node * n = &node;
  while (n)
  {
    const auto section = n->parent();
    if (section)
    {
      // only check current level, not nested ones
      if (const auto active = section->find("active");
          active && active->type() == hit::NodeType::Field && active->parent() == section)
      {
        const auto vars = active->param<std::vector<std::string>>();
        return std::find_if(vars.begin(),
                            vars.end(),
                            [&n](const auto & var)
                            { return n->path() == hit::pathNorm(var); }) != vars.end();
      }
      // only check current level, not nested ones
      if (const auto inactive = section->find("inactive");
          inactive && inactive->type() == hit::NodeType::Field && inactive->parent() == section)
      {
        const auto vars = inactive->param<std::vector<std::string>>();
        return std::find_if(vars.begin(),
                            vars.end(),
                            [&n](const auto & var)
                            { return n->path() == hit::pathNorm(var); }) == vars.end();
      }
    }
    n = section;
  }
  return true;
}

Referenced by Moose::UnusedWalker::walk(), and Moose::Builder::walkRaw().

isSolverExecFlag()

bool Moose::isSolverExecFlag

(

const ExecFlagType &

exec_flag

)

Returns

whether exec_flag is a solver execution flag, e.g. a flag on which a solver evaluation such as a residual, Jacobian, or postcheck evaluation is performed

When a solver execution flag is added to the list of execution flags above, add it to the implementation of this method as well so that logic keyed on solver evaluations, such as the MooseException handling in FEProblemBase::checkExceptionAndStopSolve(), picks it up

Definition at line 68 of file Moose.C.

{
  return exec_flag == EXEC_LINEAR || exec_flag == EXEC_NONLINEAR || exec_flag == EXEC_POSTCHECK;
}

Referenced by FEProblemBase::checkExceptionAndStopSolve(), and FEProblemBase::computeUserObjects().

main()

template<typename DefaultAppType >

int Moose::main	(	int	argc,
		char *	argv[]
	)

Initialize, create and run a MooseApp.

Definition at line 31 of file MooseMain.h.

{
  MooseInit init(argc, argv);
 
  DefaultAppType::registerApps();
 
  const auto default_app_type = MooseUtils::prettyCppType<DefaultAppType>();
 
  auto app = createMooseApp(default_app_type, argc, argv);
 
  app->run();
 
  return app->exitCode();
}

makeSpan()

template<class C >

auto Moose::makeSpan	(	C &	container,
		std::size_t	offset,
		std::size_t	n
	)

Helper function for creating a span from a given container.

This helper function will automatically deduce whether we're spanning over non-const or const elements

Definition at line 1095 of file MooseTypes.h.

{
  using PointerType = decltype(std::data(container));
  using ElementType = std::remove_pointer_t<PointerType>;
  return Moose::Span<ElementType>{std::data(container) + offset, n};
}

Referenced by TaggingInterface::addJacobian(), and TaggingInterface::addResiduals().

oldState()

StateArg Moose::oldState ( )

inline

Definition at line 162 of file MooseFunctorArguments.h.

{
  return {(unsigned int)1};
}

Referenced by TransientInterface::determineState(), and FunctorChangeFunctorMaterialTempl< is_ad >::referenceState().

previousMultiAppFixedPointState()

StateArg Moose::previousMultiAppFixedPointState ( )

inline

Definition at line 174 of file MooseFunctorArguments.h.

{
  return {(unsigned int)1, SolutionIterationType::MultiAppFixedPoint};
}

Referenced by FunctorChangeFunctorMaterialTempl< is_ad >::referenceState().

previousMultiSystemFixedPointState()

StateArg Moose::previousMultiSystemFixedPointState ( )

inline

Definition at line 180 of file MooseFunctorArguments.h.

{
  return {(unsigned int)1, SolutionIterationType::MultiSystemFixedPoint};
}

Referenced by FunctorChangeFunctorMaterialTempl< is_ad >::referenceState().

previousNonlinearState()

StateArg Moose::previousNonlinearState ( )

inline

Definition at line 168 of file MooseFunctorArguments.h.

{
  return {(unsigned int)1, SolutionIterationType::Nonlinear};
}

Referenced by FunctorChangeFunctorMaterialTempl< is_ad >::referenceState().

recursivelyFindElementsIntersectedByLine()

void Moose::recursivelyFindElementsIntersectedByLine	(	const LineSegment &	line_segment,
		const Elem *	current_elem,
		int	incoming_side,
		const Point &	incoming_point,
		std::vector< Elem * > &	intersected_elems,
		std::vector< LineSegment > &	segments
	)

Recursively find all elements intersected by a line segment.

Works by moving from one element to the next through the side of the current element. This means that (other than for the first element) there is always an incoming_side that is the reason we ended up in this element in the first place. Search all the other sides to see if there is a next element...

Parameters

line_segment	the LineSegment to intersect
current_elem	The current element that needs to be searched
incoming_side	The side of the current element that was intersected by the LineSegment that brought us here
intersected_elems	The output
segments	Line segments for the path across each element

Definition at line 144 of file RayTracing.C.

{
  Point intersection_point;
 
  std::vector<int> not_side(1, incoming_side);
 
  // Find the side of this element that the LineSegment intersects... while ignoring the incoming
  // side (we don't want to move backward!)
  int intersected_side =
      sideIntersectedByLine(current_elem, not_side, line_segment, intersection_point);
 
  if (intersected_side != -1) // -1 means that we didn't find any side
  {
    // Get the neighbor on that side
    const Elem * neighbor = current_elem->neighbor_ptr(intersected_side);
 
    if (neighbor)
    {
      // Add it to the list
      intersected_elems.push_back(const_cast<Elem *>(neighbor));
 
      // Add the line segment across the element to the segments list
      segments.push_back(LineSegment(incoming_point, intersection_point));
 
      // Note: This is finding the side the current_elem is on for the neighbor.  That's the
      // "incoming_side" for the neighbor
      int incoming_side = sideNeighborIsOn(neighbor, current_elem);
 
      // Recurse
      recursivelyFindElementsIntersectedByLine(
          line_segment, neighbor, incoming_side, intersection_point, intersected_elems, segments);
    }
    else // Add the final segment
      segments.push_back(LineSegment(incoming_point, line_segment.end()));
  }
  else // Add the final segment
    segments.push_back(LineSegment(incoming_point, line_segment.end()));
 
  // Finished... return out!
  return;
}

Referenced by elementsIntersectedByLine(), and recursivelyFindElementsIntersectedByLine().

registerActions() [1/2]

void Moose::registerActions	(	Syntax &	syntax,
		ActionFactory &	action_factory
	)

Multiple Action class can be associated with a single input file section, in which case all associated Actions will be created and "acted" on when the associated input file section is seen.

• Example: "setup_mesh" <--------—> SetupMeshAction <------— \ [Mesh] / "setup_mesh_complete" <—> SetupMeshCompleteAction <-

Action classes can also be registered to act on more than one input file section for a different task if similar logic can work in multiple cases

Example: "add_variable" <--— -> [Variables/ *] \ / CopyNodalVarsAction / \ "add_aux_variable" <- -> [AuxVariables/ *]

Note: Placeholder "no_action" actions must be put in places where it is possible to match an object with a star or a more specific parent later on. (i.e. where one needs to negate the '*' matching prematurely).

Definition at line 591 of file Moose.C.

Referenced by registerAll(), and setColorConsole().

registerActions() [2/2]

void Moose::registerActions	(	Syntax &	syntax,
		ActionFactory &	action_factory,
		const std::set< std::string > &	obj_labels
	)

Definition at line 598 of file Moose.C.

          :
 

registerAll()

void Moose::registerAll	(	Factory &	f,
		ActionFactory &	af,
		Syntax &	s
	)

Register objects that are in MOOSE.

Definition at line 76 of file Moose.C.

{
  registerObjects(f, {"MooseApp"});
  associateSyntaxInner(s, af);
  registerActions(s, af, {"MooseApp"});
  registerAppDataFilePath("moose");
  registerRepository("moose", "github.com/idaholab/moose");
 
  // Citation emitted by the --citations command-line option: the current framework paper is tied to
  // "MooseApp" (so it is cited whenever a MooseApp object is used, and apps composed of MooseApp
  // inherit it), and modules register their own app citations (via Registry::addAppCitation) which
  // are cited only when one of their objects is actually used. PETSc and its sub-packages register
  // their own citations, which --citations emits through PETSc.
  Registry::addAppCitation("MooseApp",
                           "harbour2025moose",
                           R"(@article{harbour2025moose,
  title = {4.0 {MOOSE}: Enabling massively parallel Multiphysics simulation},
  journal = {{SoftwareX}},
  volume = {31},
  pages = {102264},
  year = {2025},
  issn = {2352-7110},
  doi = {https://doi.org/10.1016/j.softx.2025.102264},
  url = {https://www.sciencedirect.com/science/article/pii/S2352711025002316},
  author = {Logan Harbour and Guillaume Giudicelli and Alexander D. Lindsay and Peter German and Joshua Hansel and Casey Icenhour and Mengnan Li and Jason M. Miller and Roy H. Stogner and Patrick Behne and Daniel Yankura and Zachary M. Prince and Corey DeChant and Daniel Schwen and Benjamin W. Spencer and Mauricio Tano and Namjae Choi and Yaqi Wang and Max Nezdyur and Yinbin Miao and Tianchen Hu and Shikhar Kumar and Christopher Matthews and Brandon Langley and Nuno Nobre and Alexander Blair and Chris MacMackin and Henrique Bergallo Rocha and Edward Palmer and Jesse Carter and J{\"o}rg Meier and Andrew E. Slaughter and David Andr{\v{s}} and Robert W. Carlsen and Fande Kong and Derek R. Gaston and Cody J. Permann},
})");
 
  // The libMesh citation is registered under "libMesh" but not tied to any object label, so the
  // per-object loop in MooseApp::requestCitations() does not emit it; emission is gated on the
  // finite element backend actually used in the run.
  Registry::addAppCitation("libMesh",
                           "libMeshPaper",

registerObjects()

void Moose::registerObjects	(	Factory &	factory,
		const std::set< std::string > &	obj_labels
	)

Definition at line 110 of file Moose.C.

          {{\texttt{libMesh}: A C++ Library for Parallel Adaptive Mesh
              Refinement/Coarsening Simulations}},
  journal = {Engineering with Computers},
  volume = {22},

Referenced by registerAll().

restrictPointToFace() [1/2]

void Moose::restrictPointToFace	(	libMesh::Point &	p,
		const Elem *	side,
		std::vector< const Node * > &	off_edge_nodes
	)

Definition at line 321 of file FindContactPoint.C.

{
  const ElemType t(side->type());
  off_edge_nodes.clear();
  Real & xi = p(0);
  Real & eta = p(1);
 
  switch (t)
  {
    case EDGE2:
    case EDGE3:
    case EDGE4:
    {
      // The reference 1D element is [-1,1].
      if (xi < -1.0)
      {
        xi = -1.0;
        off_edge_nodes.push_back(side->node_ptr(0));
      }
      else if (xi > 1.0)
      {
        xi = 1.0;
        off_edge_nodes.push_back(side->node_ptr(1));
      }
      break;
    }
 
    case TRI3:
    case TRI6:
    case TRI7:
    {
      // The reference triangle is isosceles
      // and is bound by xi=0, eta=0, and xi+eta=1.
 
      if (xi <= 0.0 && eta <= 0.0)
      {
        xi = 0.0;
        eta = 0.0;
        off_edge_nodes.push_back(side->node_ptr(0));
      }
      else if (xi > 0.0 && xi < 1.0 && eta < 0.0)
      {
        eta = 0.0;
        off_edge_nodes.push_back(side->node_ptr(0));
        off_edge_nodes.push_back(side->node_ptr(1));
      }
      else if (eta > 0.0 && eta < 1.0 && xi < 0.0)
      {
        xi = 0.0;
        off_edge_nodes.push_back(side->node_ptr(2));
        off_edge_nodes.push_back(side->node_ptr(0));
      }
      else if (xi >= 1.0 && (eta - xi) <= -1.0)
      {
        xi = 1.0;
        eta = 0.0;
        off_edge_nodes.push_back(side->node_ptr(1));
      }
      else if (eta >= 1.0 && (eta - xi) >= 1.0)
      {
        xi = 0.0;
        eta = 1.0;
        off_edge_nodes.push_back(side->node_ptr(2));
      }
      else if ((xi + eta) > 1.0)
      {
        Real delta = (xi + eta - 1.0) / 2.0;
        xi -= delta;
        eta -= delta;
        off_edge_nodes.push_back(side->node_ptr(1));
        off_edge_nodes.push_back(side->node_ptr(2));
      }
      break;
    }
 
    case QUAD4:
    case QUAD8:
    case QUAD9:
    {
      // The reference quadrilateral element is [-1,1]^2.
      if (xi < -1.0)
      {
        xi = -1.0;
        if (eta < -1.0)
        {
          eta = -1.0;
          off_edge_nodes.push_back(side->node_ptr(0));
        }
        else if (eta > 1.0)
        {
          eta = 1.0;
          off_edge_nodes.push_back(side->node_ptr(3));
        }
        else
        {
          off_edge_nodes.push_back(side->node_ptr(3));
          off_edge_nodes.push_back(side->node_ptr(0));
        }
      }
      else if (xi > 1.0)
      {
        xi = 1.0;
        if (eta < -1.0)
        {
          eta = -1.0;
          off_edge_nodes.push_back(side->node_ptr(1));
        }
        else if (eta > 1.0)
        {
          eta = 1.0;
          off_edge_nodes.push_back(side->node_ptr(2));
        }
        else
        {
          off_edge_nodes.push_back(side->node_ptr(1));
          off_edge_nodes.push_back(side->node_ptr(2));
        }
      }
      else
      {
        if (eta < -1.0)
        {
          eta = -1.0;
          off_edge_nodes.push_back(side->node_ptr(0));
          off_edge_nodes.push_back(side->node_ptr(1));
        }
        else if (eta > 1.0)
        {
          eta = 1.0;
          off_edge_nodes.push_back(side->node_ptr(2));
          off_edge_nodes.push_back(side->node_ptr(3));
        }
      }
      break;
    }
 
    default:
    {
      mooseError("Unsupported face type: ", t);
      break;
    }
  }
}

restrictPointToFace() [2/2]

void Moose::restrictPointToFace	(	libMesh::Point &	p,
		const libMesh::Elem *	side,
		std::vector< const libMesh::Node * > &	off_edge_nodes
	)

Referenced by findContactPoint().

SERIAL_ACCESS_CONST_SIZE() [1/3]

Moose::SERIAL_ACCESS_CONST_SIZE	(	libMesh::VectorValue	,
		&	obj0u,
		Moose::dim
	)

SERIAL_ACCESS_CONST_SIZE() [2/3]

Moose::SERIAL_ACCESS_CONST_SIZE	(	RankFourTensorTempl	,
		&	obj0u, 0u, 0u, 0u,
		RankFourTensorTempl< T >::N4
	)

SERIAL_ACCESS_CONST_SIZE() [3/3]

Moose::SERIAL_ACCESS_CONST_SIZE	(	RankTwoTensorTempl	,
		&	obj0u, 0u,
		RankTwoTensorTempl< T >::N2
	)

SERIAL_ACCESS_DYNAMIC_SIZE()

Moose::SERIAL_ACCESS_DYNAMIC_SIZE	(	DenseVector	,
		&	obj0u,
		obj.	size()
	)

SERIAL_ACCESS_SCALAR() [1/2]

Moose::SERIAL_ACCESS_SCALAR

(

ADReal

)

SERIAL_ACCESS_SCALAR() [2/2]

Moose::SERIAL_ACCESS_SCALAR

(

Real

)

serialAccess()

template<typename T >

SerialAccessRange< T > Moose::serialAccess

(

T &

obj

)

Definition at line 151 of file SerialAccess.h.

{
  return SerialAccessRange<T>(obj);
}

Referenced by InterpolatedStatefulMaterialTempl< T >::computeQpProperties(), ProjectedStatefulMaterialAuxTempl< T, is_ad >::computeValue(), and ProjectedStatefulMaterialNodalPatchRecoveryTempl< T, is_ad >::execute().

setColorConsole()

bool Moose::setColorConsole	(	bool	use_color,
		bool	force = false
	)

Turns color escape sequences on/off for info written to stdout.

Returns the the set value which may be different than use_color.

Definition at line 877 of file Moose.C.

{
  associateSyntaxInner(syntax, action_factory);
  registerActions(syntax, action_factory);
}
 

Referenced by CommonOutputAction::act(), and MooseApp::setupOptions().

setSolverDefaults()

void Moose::setSolverDefaults

(

FEProblemBase &

problem

)

Definition at line 854 of file Moose.C.

sideIntersectedByLine()

int Moose::sideIntersectedByLine	(	const Elem *	elem,
		std::vector< int > &	not_side,
		const LineSegment &	line_segment,
		Point &	intersection_point
	)

Figure out which (if any) side of an Elem is intersected by a line.

Parameters

elem	The elem to search
not_side	Sides to not search (Use -1 if you want to search all sides)
intersection_point	If an intersection is found this will be filled with the x,y,z position of that intersection

Returns

The side that is intersected by the line. Will return -1 if it doesn't intersect any side

Definition at line 34 of file RayTracing.C.

{
  unsigned int n_sides = elem->n_sides();
 
  // Whether or not they intersect
  bool intersect = false;
 
  unsigned int dim = elem->dim();
 
  for (unsigned int i = 0; i < n_sides; i++)
  {
    // Don't search the "not_side"
    // Note: A linear search is fine here because this vector is going to be < n_sides
    if (std::find(not_side.begin(), not_side.end(), static_cast<int>(i)) != not_side.end())
      continue;
 
    // Get a simplified side element
    std::unique_ptr<const Elem> side_elem = elem->side_ptr(i);
 
    if (dim == 3)
    {
      // Make a plane out of the first three nodes on the side
      libMesh::Plane plane(side_elem->point(0), side_elem->point(1), side_elem->point(2));
 
      // See if they intersect
      intersect = line_segment.intersect(plane, intersection_point);
    }
    else if (dim == 2)
    {
      // Make a Line Segment out of the first two nodes on the side
      LineSegment side_segment(side_elem->point(0), side_elem->point(1));
 
      // See if they intersect
      intersect = line_segment.intersect(side_segment, intersection_point);
    }
    else // 1D
    {
      // See if the line segment contains the point
      intersect = line_segment.contains_point(side_elem->point(0));
 
      // If it does then save off that one point as the intersection point
      if (intersect)
        intersection_point = side_elem->point(0);
    }
 
    if (intersect)
    {
      if (side_elem->contains_point(intersection_point))
      {
        const Elem * neighbor = elem->neighbor_ptr(i);
 
        // If this side is on a boundary, let's do another search and see if we can find a better
        // candidate
        if (!neighbor)
        {
          not_side.push_back(i); // Make sure we don't find this side again
 
          int better_side = sideIntersectedByLine(elem, not_side, line_segment, intersection_point);
 
          if (better_side != -1)
            return better_side;
        }
 
        return i;
      }
    }
  }
 
  // Didn't find one
  return -1;
}

Referenced by recursivelyFindElementsIntersectedByLine(), and sideIntersectedByLine().

sideNeighborIsOn()

int Moose::sideNeighborIsOn	(	const Elem *	elem,
		const Elem *	neighbor
	)

Returns the side number for elem that neighbor is on.

Returns -1 if the neighbor can't be found to be a neighbor

Definition at line 115 of file RayTracing.C.

{
  unsigned int n_sides = elem->n_sides();
 
  for (unsigned int i = 0; i < n_sides; i++)
  {
    if (elem->neighbor_ptr(i) == neighbor)
      return i;
  }
 
  return -1;
}

Referenced by recursivelyFindElementsIntersectedByLine().

stringify() [1/22]

std::string Moose::stringify ( bool  v )

inline

Definition at line 73 of file Conversion.h.

{
  return v ? "true" : "false";
}

stringify() [2/22]

std::string Moose::stringify

(

const EigenSolveType &

t

)

Convert eigen solve type into human readable string.

Definition at line 401 of file Conversion.C.

{
  switch (t)
  {
    case EST_POWER:
      return "Power";
    case EST_ARNOLDI:
      return "ARNOLDI";
    case EST_KRYLOVSCHUR:
      return "KRYLOVSCHUR";
    case EST_JACOBI_DAVIDSON:
      return "Jacobi Davidson";
    case EST_NONLINEAR_POWER:
      return "Nonlinear Power";
    case EST_PJFNKMO:
      return "PJFNK with Matrix Only";
    case EST_NEWTON:
      return "Newton";
    case EST_JFNK:
      return "JFNK";
    case EST_PJFNK:
      return "Preconditioned JFNK";
  }
  return "";
}

stringify() [3/22]

std::string Moose::stringify

(

const Moose::RelationshipManagerType &

t

)

Definition at line 324 of file Conversion.C.

{
  // Cannot make a switch statement because the boolean logic doesn't work well with the class type
  // enumeration and because Cody says so.
  if (t == RelationshipManagerType::DEFAULT)
    return "DEFAULT";
  if (t == RelationshipManagerType::GEOMETRIC)
    return "GEOMETRIC";
  if (t == RelationshipManagerType::ALGEBRAIC)
    return "ALGEBRAIC";
  if (t == (RelationshipManagerType::GEOMETRIC | RelationshipManagerType::ALGEBRAIC))
    return "GEOMETRIC and ALGEBRAIC";
  if (t == (RelationshipManagerType::ALGEBRAIC | RelationshipManagerType::COUPLING))
    return "ALGEBRAIC and COUPLING";
  if (t == (RelationshipManagerType::GEOMETRIC | RelationshipManagerType::ALGEBRAIC |
            RelationshipManagerType::COUPLING))
    return "GEOMETRIC and ALGEBRAIC and COUPLING";
  if (t == RelationshipManagerType::COUPLING)
    return "COUPLING";
 
  mooseError("Unknown RelationshipManagerType");
}

stringify() [4/22]

std::string Moose::stringify

(

const Moose::TimeIntegratorType &

t

)

Definition at line 349 of file Conversion.C.

{
  switch (t)
  {
    case TimeIntegratorType::TI_IMPLICIT_EULER:
      return "IMPLICIT_EULER";
    case TimeIntegratorType::TI_EXPLICIT_EULER:
      return "EXPLICIT_EULER";
    case TimeIntegratorType::TI_CRANK_NICOLSON:
      return "CRANK_NICOLSON";
    case TimeIntegratorType::TI_BDF2:
      return "BDF2";
    case TimeIntegratorType::TI_EXPLICIT_MIDPOINT:
      return "EXPLICIT_MIDPOINT";
    case TimeIntegratorType::TI_LSTABLE_DIRK2:
      return "LSTABLE_DIRK2";
    case TimeIntegratorType::TI_EXPLICIT_TVD_RK_2:
      return "EXPLICIT_TVDRK2";
    default:
      mooseError("Unknown TimeIntegratorType");
  }
}

stringify() [5/22]

std::string Moose::stringify

(

const SolveType &

t

)

Convert solve type into human readable string.

Definition at line 382 of file Conversion.C.

{
  switch (t)
  {
    case ST_NEWTON:
      return "NEWTON";
    case ST_JFNK:
      return "JFNK";
    case ST_PJFNK:
      return "Preconditioned JFNK";
    case ST_FD:
      return "FD";
    case ST_LINEAR:
      return "Linear";
  }
  return "";
}

stringify() [6/22]

template<typename T , typename U >

std::string Moose::stringify	(	const std::pair< T, U > &	p,
		const std::string &	delim = ":"
	)

Add pair stringify to support maps.

Definition at line 154 of file Conversion.h.

                                                              :")
{
  return stringify(p.first) + delim + stringify(p.second);
}

stringify() [7/22]

std::string Moose::stringify

(

const std::string &

s

)

Add no-op stringify if the argument already is a string (must use overloading)

Definition at line 487 of file Conversion.C.

{
  return s;
}

stringify() [8/22]

template<typename... Args>

std::string Moose::stringify	(	const std::tuple< Args... > &	t,
		const std::string &	delim = ":"
	)

Add tuple stringify.

Definition at line 162 of file Conversion.h.

                                                                  :")
{
  if constexpr (sizeof...(Args) == 0)
  {
    return "";
  }
 
  return std::apply(
      [&delim](const auto &... args)
      {
        std::size_t n{0};
        std::string result;
        ((result += (n++ == 0 ? "" : delim) + stringify(args)), ...);
        return result;
      },
      t);
}

stringify() [9/22]

template<typename T >

std::string Moose::stringify

(

const T &

t

)

conversion to string

Definition at line 64 of file Conversion.h.

{
  std::ostringstream os;
  os << t;
  return os.str();
}

Referenced by MaterialDerivativeTestAction::act(), SetupResidualDebugAction::act(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), PhysicsComponentInterface::addBoundaryConditionsFromComponents(), PhysicsComponentInterface::addInitialConditionsFromComponents(), LinearFVFluxKernel::addMatrixContribution(), ComponentPhysicsInterface::addPhysics(), AddActionComponentAction::addRelationshipManagers(), LinearFVFluxKernel::addRightHandSideContribution(), MooseVariableData< OutputType >::adGradPhi(), MooseVariableData< OutputType >::adGradPhiFace(), MooseEnum::assign(), MooseEnum::assign(), AuxKernelBase::AuxKernelBase(), MooseMeshUtils::buildLoopBoundaryOf2DMesh(), ParsedFunctorMaterialTempl< is_ad >::buildParsedFunction(), CartesianMeshGenerator::CartesianMeshGenerator(), Moose::BSpline::CdBBasis(), PhysicsBase::checkBlockRestrictionIdentical(), InputParametersChecksUtils< C >::checkBlockwiseConsistency(), MooseMesh::checkCoordinateSystems(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), FEProblemBase::checkExceptionAndStopSolve(), Moose::FunctorBase< T >::checkFace(), MeshGenerator::checkGetMesh(), Steady::checkIntegrity(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), MeshDiagnosticsGenerator::checkPolygons(), FEProblemBase::checkProblemIntegrity(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), InputParametersChecksUtils< C >::checkTwoDVectorParamsNoRespectiveOverlap(), BlockRestrictable::checkVariable(), InputParametersChecksUtils< C >::checkVectorParamsNoOverlap(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), Moose::SlepcSupport::clearFreeNonlinearPowerIterations(), FEProblemBase::computeUserObjectsInternal(), CopyValueAux::CopyValueAux(), PhysicsBase::copyVariablesFromMesh(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::createInternal(), Moose::Kokkos::dataLoad(), DebugResidualAux::DebugResidualAux(), DGKernelBase::DGKernelBase(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), FEProblemBase::duplicateVariableCheck(), MonotoneCubicInterpolation::errorCheck(), UnitsConversionEvaler::eval(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), DOFMapOutput::filename(), ElementQualityChecker::finalize(), DiracKernelInfo::findPoint(), ParsedMaterialHelper< is_ad >::functionParse(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), AdvancedExtruderGenerator::generate(), CoarsenBlockGenerator::generate(), ExtraNodesetGenerator::generate(), RefineBlockGenerator::generate(), ActionWarehouse::getAction(), FunctorBinnedValuesDivision::getBinIndex(), ComputeFVFluxThread< RangeType, AttributeTagType >::getBlockNames(), MeshCoarseningUtils::getFineElementsFromInteriorNode(), SolutionUserObjectBase::getLocalVarIndex(), MooseEnumBase::getRawNames(), MooseApp::getRelationshipManagerInfo(), SystemBase::getScalarVariable(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), SystemBase::getVariable(), Moose::FV::harmonicInterpolation(), ParsedDownSelectionPositions::initialize(), BlockRestrictable::initializeBlockRestrictable(), MultiAppGeneralFieldTransfer::initialSetup(), MatrixTools::inverse(), LeastSquaresFitHistory::LeastSquaresFitHistory(), MultiApp::localApp(), ParsedConvergence::makeParsedFunction(), MeshDivisionAux::MeshDivisionAux(), MultiAppTransfer::MultiAppTransfer(), SystemBase::oldSolutionStateVectorName(), ComputeLinearFVLimitedGradientThread::operator()(), MaterialOutputAction::outputHelper(), Parser::parse(), PatternedMeshGenerator::PatternedMeshGenerator(), ProjectSideSetOntoLevelSetGenerator::pointPairLevelSetInterception(), CompileTimeDerivatives::CTValue< tag, T >::print(), CompileTimeDerivatives::CTArrayRef< tag, T, I >::print(), CompileTimeDerivatives::CTIPow< B, E >::print(), libMesh::print_helper(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), CompileTimeDerivatives::printTag(), TopResidualDebugOutput::printTopResiduals(), ProjectedStatefulMaterialStorageAction::processProperty(), DerivativeParsedMaterialHelperTempl< is_ad >::recurseMatProps(), CoarsenBlockGenerator::recursiveCoarsen(), Moose::internal::Capabilities::registerMooseCapabilities(), PhysicsBase::reportPotentiallyMissedParameters(), Moose::Kokkos::Thread< thread_id_type, max_dimension >::resize(), PicardSolve::saveVariableValues(), SecantSolve::saveVariableValues(), SteffensenSolve::saveVariableValues(), MeshRepairGenerator::separateSubdomainsByElementType(), MooseMesh::setCoordSystem(), Moose::SlepcSupport::setFreeNonlinearPowerIterations(), Moose::SlepcSupport::setNewtonPetscOptions(), Moose::SlepcSupport::setSlepcEigenSolverTolerances(), Split::setup(), MultiSystemSolveObject::setupMultiSystemFixedPointRelaxationFactors(), SamplerBase::setupVariables(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), PhysicsBase::shouldCreateVariable(), SystemBase::solutionState(), FEProblemBase::solverSysNum(), FEProblemBase::solverTypeString(), EigenProblem::solverTypeString(), StitchMeshGenerator::StitchMeshGenerator(), NonlinearSystem::stopSolve(), stringify(), stringify(), stringify(), Moose::internal::stringify_variant(), PiecewiseByBlockLambdaFunctor< T >::subdomainErrorMessage(), PiecewiseByBlockLambdaFunctor< T >::subdomainNameAndID(), and FEProblemSolve::validParams().

stringify() [10/22]

template<template< typename... > class T, typename... U>

std::string Moose::stringify	(	const T< U... > &	c,
		const std::string &	delim = ", ",
		const std::string &	elem_encl = "",
		bool	enclose_list_in_curly_braces = false
	)

Convert a container to a string with elements separated by delimiter of user's choice.

Optionally, the container elements can be enclosed by curly braces and can enclose elements in quotations (or other characters) to make the separation of elements more clear.

Parameters

[in]	c	Container to stringify
[in]	delim	String to print between elements
[in]	elem_encl	String to use at the beginning and end of each element, typically quotation marks
[in]	enclose_list_in_curly_braces	Enclose the list string in curly braces?

Definition at line 195 of file Conversion.h.

{
  std::string str;
  if (enclose_list_in_curly_braces)
    str += "{";
  const auto begin = c.begin();
  const auto end = c.end();
  for (auto i = begin; i != end; ++i)
    str += (i != begin ? delim : "") + elem_encl + stringify(*i) + elem_encl;
  if (enclose_list_in_curly_braces)
    str += "}";
  return str;
}

stringify() [11/22]

std::string Moose::stringify

(

const VarFieldType &

t

)

Convert variable field type into human readable string.

Definition at line 428 of file Conversion.C.

{
  switch (t)
  {
    case VAR_FIELD_STANDARD:
      return "STANDARD";
    case VAR_FIELD_VECTOR:
      return "VECTOR";
    case VAR_FIELD_ARRAY:
      return "ARRAY";
    case VAR_FIELD_SCALAR:
      return "SCALAR";
    case VAR_FIELD_ANY:
      return "ANY";
  }
  return "";
}

stringify() [12/22]

std::string Moose::stringify

(

ElementType

t

)

Convert ElementType into string.

Definition at line 465 of file Conversion.C.

{
  switch (t)
  {
    case ElementType::Element:
      return "ELEMENT";
    case ElementType::Neighbor:
      return "NEIGHBOR";
    case ElementType::Lower:
      return "LOWER";
    default:
      mooseError("unrecognized type");
  }
}

stringify() [13/22]

std::string Moose::stringify ( int  v )

inline

Definition at line 80 of file Conversion.h.

{
  return std::to_string(v);
}

stringify() [14/22]

std::string Moose::stringify

(

libMesh::ElemType

t

)

Convert the libmesh ElemType into string.

Definition at line 481 of file Conversion.C.

{
  return libMesh::Utility::enum_to_string(t);
}

stringify() [15/22]

std::string Moose::stringify

(

libMesh::FEFamily

f

)

Convert FEType from libMesh into string.

Definition at line 373 of file Conversion.C.

{
  return libMesh::Utility::enum_to_string(f);
}

stringify() [16/22]

std::string Moose::stringify ( long long  v )

inline

Definition at line 90 of file Conversion.h.

{
  return std::to_string(v);
}

stringify() [17/22]

std::string Moose::stringify ( long  v )

inline

Definition at line 85 of file Conversion.h.

{
  return std::to_string(v);
}

stringify() [18/22]

std::string Moose::stringify

(

SolutionIterationType

t

)

Convert SolutionIterationType into string.

Definition at line 447 of file Conversion.C.

{
  switch (t)
  {
    case SolutionIterationType::Time:
      return "time";
    case SolutionIterationType::Nonlinear:
      return "nonlinear";
    case SolutionIterationType::MultiAppFixedPoint:
      return "multiapp_fixed_point";
    case SolutionIterationType::MultiSystemFixedPoint:
      return "multisystem_fixed_point";
    default:
      mooseError("Unhandled SolutionIterationType");
  }
}

stringify() [19/22]

template<typename... T>

std::string Moose::stringify ( std::variant< T... >  v )

inline

Definition at line 122 of file Conversion.h.

{
  return (internal::stringify_variant<T>(v) + ...);
}

stringify() [20/22]

std::string Moose::stringify ( unsigned int  v )

inline

Definition at line 95 of file Conversion.h.

{
  return std::to_string(v);
}

stringify() [21/22]

std::string Moose::stringify ( unsigned long long  v )

inline

Definition at line 105 of file Conversion.h.

{
  return std::to_string(v);
}

stringify() [22/22]

std::string Moose::stringify ( unsigned long  v )

inline

Definition at line 100 of file Conversion.h.

{
  return std::to_string(v);
}

stringifyExact()

std::string Moose::stringifyExact

(

Real

t

)

Stringify Reals with enough precision to guarantee lossless Real -> string -> Real roundtrips.

Definition at line 493 of file Conversion.C.

{
  // this or std::numeric_limits<T>::max_digits10
  const unsigned int max_digits10 =
      std::floor(std::numeric_limits<Real>::digits * std::log10(2) + 2);
 
  std::ostringstream os;
  os << std::setprecision(max_digits10) << t;
  return os.str();
}

stringToEnum()

template<typename T >

T Moose::stringToEnum

(

const std::string &

s

)

stringToEnum< CoordinateSystemType >() [1/2]

template<>

CoordinateSystemType Moose::stringToEnum< CoordinateSystemType >

(

const std::string &

s

)

Definition at line 185 of file Conversion.C.

{
  initCoordinateSystemType();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!coordinate_system_type_to_enum.count(upper))
    mooseError("Unknown coordinate system type: ", upper);
 
  return coordinate_system_type_to_enum[upper];
}

stringToEnum< CoordinateSystemType >() [2/2]

template<>

CoordinateSystemType Moose::stringToEnum< CoordinateSystemType >

(

const std::string &

s

)

Definition at line 185 of file Conversion.C.

{
  initCoordinateSystemType();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!coordinate_system_type_to_enum.count(upper))
    mooseError("Unknown coordinate system type: ", upper);
 
  return coordinate_system_type_to_enum[upper];
}

stringToEnum< EigenProblemType >()

template<>

EigenProblemType Moose::stringToEnum< EigenProblemType >

(

const std::string &

s

)

Definition at line 230 of file Conversion.C.

{
  initEigenProlemType();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!eigen_problem_type_to_enum.count(upper))
    mooseError("Unknown eigen problem type: ", upper);
 
  return eigen_problem_type_to_enum[upper];
}

stringToEnum< EigenSolveType >()

template<>

EigenSolveType Moose::stringToEnum< EigenSolveType >

(

const std::string &

s

)

Definition at line 215 of file Conversion.C.

{
  initEigenSolveType();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!eigen_solve_type_to_enum.count(upper))
    mooseError("Unknown eigen solve type: ", upper);
 
  return eigen_solve_type_to_enum[upper];
}

stringToEnum< libMesh::Order >()

template<>

libMesh::Order Moose::stringToEnum< libMesh::Order >

(

const std::string &

s

)

stringToEnum< libMesh::QuadratureType >()

template<>

libMesh::QuadratureType Moose::stringToEnum< libMesh::QuadratureType >

(

const std::string &

s

)

Referenced by SetupQuadratureAction::SetupQuadratureAction().

stringToEnum< LineSearchType >() [1/2]

template<>

LineSearchType Moose::stringToEnum< LineSearchType >

(

const std::string &

s

)

Definition at line 260 of file Conversion.C.

{
  initLineSearchType();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!line_search_type_to_enum.count(upper))
    mooseError("Unknown line search type: ", upper);
 
  return line_search_type_to_enum[upper];
}

stringToEnum< LineSearchType >() [2/2]

template<>

LineSearchType Moose::stringToEnum< LineSearchType >

(

const std::string &

s

)

Definition at line 260 of file Conversion.C.

{
  initLineSearchType();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!line_search_type_to_enum.count(upper))
    mooseError("Unknown line search type: ", upper);
 
  return line_search_type_to_enum[upper];
}

stringToEnum< MffdType >()

template<>

MffdType Moose::stringToEnum< MffdType >

(

const std::string &

s

)

Definition at line 290 of file Conversion.C.

{
  initMffdType();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!mffd_type_to_enum.count(upper))
    mooseError("Unknown mffd type: ", upper);
 
  return mffd_type_to_enum[upper];
}

stringToEnum< Order >()

template<>

Order Moose::stringToEnum< Order >

(

const std::string &

s

)

Definition at line 172 of file Conversion.C.

{
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (upper.compare("AUTO") == 0)
    return INVALID_ORDER;
  else
    return Utility::string_to_enum<Order>(upper);
}

Referenced by SetupQuadratureAction::act(), and DeleteElementsNearMeshGenerator::generate().

stringToEnum< QuadratureType >()

template<>

QuadratureType Moose::stringToEnum< QuadratureType >

(

const std::string &

s

)

Definition at line 165 of file Conversion.C.

{
  return Utility::string_to_enum<QuadratureType>("Q" + s);
}

stringToEnum< RelationshipManagerType >() [1/2]

template<>

RelationshipManagerType Moose::stringToEnum< RelationshipManagerType >

(

const std::string &

s

)

Definition at line 305 of file Conversion.C.

{
  initRMType();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!rm_type_to_enum.count(upper))
    mooseError("Unknown RelationshipManager type: ", upper);
 
  return rm_type_to_enum[upper];
}

stringToEnum< RelationshipManagerType >() [2/2]

template<>

RelationshipManagerType Moose::stringToEnum< RelationshipManagerType >

(

const std::string &

s

)

Definition at line 305 of file Conversion.C.

{
  initRMType();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!rm_type_to_enum.count(upper))
    mooseError("Unknown RelationshipManager type: ", upper);
 
  return rm_type_to_enum[upper];
}

stringToEnum< SolveType >() [1/2]

template<>

SolveType Moose::stringToEnum< SolveType >

(

const std::string &

s

)

Definition at line 200 of file Conversion.C.

{
  initSolveType();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!solve_type_to_enum.count(upper))
    mooseError("Unknown solve type: ", upper);
 
  return solve_type_to_enum[upper];
}

stringToEnum< SolveType >() [2/2]

template<>

SolveType Moose::stringToEnum< SolveType >

(

const std::string &

s

)

Definition at line 200 of file Conversion.C.

{
  initSolveType();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!solve_type_to_enum.count(upper))
    mooseError("Unknown solve type: ", upper);
 
  return solve_type_to_enum[upper];
}

stringToEnum< TimeIntegratorType >() [1/2]

template<>

TimeIntegratorType Moose::stringToEnum< TimeIntegratorType >

(

const std::string &

s

)

Definition at line 275 of file Conversion.C.

{
  initTimeIntegratorsType();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!time_integrator_to_enum.count(upper))
    mooseError("Unknown time integrator: ", upper);
 
  return time_integrator_to_enum[upper];
}

stringToEnum< TimeIntegratorType >() [2/2]

template<>

TimeIntegratorType Moose::stringToEnum< TimeIntegratorType >

(

const std::string &

s

)

Definition at line 275 of file Conversion.C.

{
  initTimeIntegratorsType();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!time_integrator_to_enum.count(upper))
    mooseError("Unknown time integrator: ", upper);
 
  return time_integrator_to_enum[upper];
}

stringToEnum< WhichEigenPairs >()

template<>

WhichEigenPairs Moose::stringToEnum< WhichEigenPairs >

(

const std::string &

s

)

Definition at line 245 of file Conversion.C.

{
  initWhichEigenPairs();
 
  std::string upper(s);
  std::transform(upper.begin(), upper.end(), upper.begin(), ::toupper);
 
  if (!which_eigen_pairs_to_enum.count(upper))
    mooseError("Unknown type of WhichEigenPairs: ", upper);
 
  return which_eigen_pairs_to_enum[upper];
}

swapLibMeshComm()

MPI_Comm Moose::swapLibMeshComm

(

MPI_Comm

new_comm

)

Swap the libMesh MPI communicator out for ours.

Note that you should usually use the Moose::ScopedCommSwapper class instead of calling this function.

Definition at line 861 of file Moose.C.

Referenced by Moose::ScopedCommSwapper::forceSwap(), and Moose::ScopedCommSwapper::~ScopedCommSwapper().

to_json()

void Moose::to_json	(	nlohmann::json &	json,
		const Moose::LibtorchArtificialNeuralNet *const &	network
	)

Definition at line 151 of file LibtorchArtificialNeuralNet.C.

{
  if (network)
    network->store(json);
}

toPoint()

Point Moose::toPoint

(

const std::vector< Real > &

pos

)

Definition at line 505 of file Conversion.C.

{
  mooseAssert(pos.size() == LIBMESH_DIM, "Wrong array size while converting into a point");
  return Point(pos[0], pos[1], pos[2]);
}

typeLoop()

template<template< typename, int > class L, typename... Ts, typename... As>

void Moose::typeLoop	(	TypeList< Ts... >	,
		As...	args
	)

Type loop.

Definition at line 178 of file SerialAccess.h.

{
  typeLoopInternal<L, 0>(TypeList<Ts...>{}, args...);
}

typeLoopInternal()

template<template< typename, int > class L, int I, typename T , typename... Ts, typename... As>

void Moose::typeLoopInternal	(	TypeList< T, Ts... >	,
		As...	args
	)

Type loop.

Definition at line 168 of file SerialAccess.h.

{
  L<T, I>::apply(args...);
  if constexpr (sizeof...(Ts) > 0)
    typeLoopInternal<L, I + 1>(TypeList<Ts...>{}, args...);
}

vectorStringsToEnum()

template<typename T >

std::vector< T > Moose::vectorStringsToEnum

(

const MultiMooseEnum &

v

)

Variable Documentation

_color_console

bool Moose::_color_console = isatty(fileno(stdout))

static

Definition at line 868 of file Moose.C.

Referenced by Moose::ScopedDeprecatedIsError::ScopedDeprecatedIsError().

_deprecated_is_error

bool Moose::_deprecated_is_error = false

Variable to toggle only deprecated warnings as errors.

Definition at line 921 of file Moose.C.

Referenced by moose::internal::mooseDeprecatedStream(), and MooseApp::setupOptions().

_throw_on_error

bool Moose::_throw_on_error = false

Variable to turn on exceptions during mooseError(), should only be used within MOOSE unit tests or when about to perform threaded operations because exception throwing in threaded regions is safe while aborting is inherently not when singletons are involved (e.g.

what thread is responsible for destruction, or what do you do about mutexes?)

Definition at line 922 of file Moose.C.

Referenced by moose::internal::mooseErrorRaw(), MooseApp::run(), CommandLine::setCommandLineParam(), ThreadedFaceLoop< RangeType >::ThreadedFaceLoop(), and ThreadedFaceLoop< RangeType >::~ThreadedFaceLoop().

_throw_on_warning

bool Moose::_throw_on_warning = false

Variable to turn on exceptions during mooseWarning(), should only be used in MOOSE unit tests.

Definition at line 923 of file Moose.C.

Referenced by moose::internal::mooseUnusedStream(), and moose::internal::mooseWarningStream().

_trap_fpe

bool Moose::_trap_fpe

extern

Variable indicating whether we will enable FPE trapping for this run.

_warnings_are_errors

bool Moose::_warnings_are_errors = false

Variable to toggle any warning into an error (includes deprecated code warnings)

Definition at line 920 of file Moose.C.

Referenced by moose::internal::mooseWarningStream(), and MooseApp::setupOptions().

always_false

template<class... Ts>

constexpr std::false_type Moose::always_false {}

constexpr

This is a helper variable template for cases when we want to use a default compile-time error with constexpr-based if conditions.

The templating delays the triggering of the static assertion until the template is instantiated.

Definition at line 640 of file MooseTypes.h.

{};

ANY_BLOCK_ID

const SubdomainID Moose::ANY_BLOCK_ID = libMesh::Elem::invalid_subdomain_id - 1

Definition at line 19 of file MooseTypes.C.

Referenced by SetupQuadratureAction::act(), FVInitialConditionWarehouse::addObject(), InitialConditionWarehouse::addObject(), BlockRestrictable::blockIDs(), BlockRestrictable::blockRestricted(), Assembly::bumpAllQRuleOrder(), Assembly::bumpVolumeQRuleOrder(), ElementSubdomainModifierBase::findReinitializedElemsAndNodes(), BlockRestrictable::hasBlocks(), BlockRestrictable::hasBlocks(), AttribSubdomains::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), ElementSubdomainModifierBase::initialSetup(), BlockRestrictable::isBlockSubset(), AttribSubdomains::isMatch(), Assembly::qrules(), PiecewiseByBlockLambdaFunctor< T >::setFunctor(), and ElementSubdomainModifierBase::subdomainIsReinitialized().

ANY_BOUNDARY_ID

const BoundaryID Moose::ANY_BOUNDARY_ID = static_cast<BoundaryID>(-1)

Definition at line 21 of file MooseTypes.C.

Referenced by SubProblem::checkBoundaryMatProps(), SubProblem::getMaterialPropertyBoundaryNames(), BoundaryRestrictable::hasBoundary(), BoundaryRestrictable::hasBoundary(), hasBoundary(), BoundaryRestrictable::hasBoundaryMaterialPropertyHelper(), AttribBoundaries::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), BoundaryRestrictable::isBoundarySubset(), AttribBoundaries::isMatch(), ComputeUserObjectsThread::printBlockExecutionInformation(), and BoundaryRestrictable::restricted().

constMaxQpsPerElem

constexpr std::size_t Moose::constMaxQpsPerElem = 1000

constexpr

This is used for places where we initialize some qp-sized data structures that would end up being sized too small after the quadrature order gets bumped (dynamically in-sim).

So for these cases, we just use this constant to size those data structures overly large to accommodate rather than come up with some overkill complex mechanism for dynamically resizing them. Eventually, we may need or implement that more sophisticated mechanism and will no longer need this.

Definition at line 258 of file MooseTypes.h.

Referenced by MaterialPropertyInterface::defaultGenericMaterialProperty(), and FEProblemBase::updateMaxQps().

coordinate_system_type_to_enum

std::map<std::string, CoordinateSystemType> Moose::coordinate_system_type_to_enum

Definition at line 24 of file Conversion.C.

Referenced by initCoordinateSystemType(), and stringToEnum< CoordinateSystemType >().

dim

constexpr std::size_t Moose::dim = LIBMESH_DIM

staticconstexpr

This is the dimension of all vector and tensor datastructures used in MOOSE.

We enforce LIBMESH_DIM == 3 through a static assertion above. Note that lower dimensional simulations embedded in 3D space can always be requested at runtime.

Definition at line 175 of file Moose.h.

Referenced by ADNodalBCTempl< Real, ADDirichletBCBase >::addResidual(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), ParsedFunctorMaterialTempl< is_ad >::buildParsedFunction(), Moose::Kokkos::Vector3< T >::cartesian_product(), ColumnMajorMatrixTempl< T >::ColumnMajorMatrixTempl(), ColumnMajorMatrixTempl< Real >::ColumnMajorMatrixTempl(), LinearFVAnisotropicDiffusion::computeBoundaryMatrixContribution(), LinearFVAnisotropicDiffusionFunctorNeumannBC::computeBoundaryNormalGradient(), LinearFVAnisotropicDiffusion::computeBoundaryRHSContribution(), LinearFVAnisotropicDiffusion::computeFluxMatrixContribution(), LinearFVAnisotropicDiffusion::computeFluxRHSContribution(), GenericFunctionVectorMaterialTempl< is_ad >::computeQpFunctions(), ElementW1pError::computeQpIntegral(), GenericConstantVectorMaterialTempl< is_ad >::computeQpProperties(), FVAnisotropicDiffusion::computeQpResidual(), ArrayParsedAux::computeValue(), ElementH1ErrorFunctionAux::computeValue(), ParsedAux::computeValue(), ParsedVectorAux::computeValue(), Moose::Kokkos::Real33::contract(), BatchMeshGeneratorAction::convertStringToCompoundRealScalar(), Moose::Kokkos::curlFromVectorGradient(), Moose::Kokkos::dataLoad(), dataLoad(), dataLoad(), dataLoad(), Moose::Kokkos::dataStore(), dataStore(), dataStore(), dataStore(), MooseMesh::detectOrthogonalDimRanges(), Moose::Kokkos::Real33::determinant(), SideDiffusiveFluxIntegralTempl< is_ad, T >::diffusivityGradientProduct(), MoveNodesByParsedExpressionModifier::displaceNode(), InitialConditionTempl< T >::dotHelper(), Moose::MFEM::NLCurlCurlJacMatrixCoefficient::Eval(), IntersectionPointsAlongLine::execute(), LinearFVAnisotropicDiffusion::faceDiffusionTensor(), MooseVariableData< OutputType >::fill(), ColumnMajorMatrixTempl< T >::fill(), findContactPoint(), GenericFunctionVectorMaterialTempl< is_ad >::GenericFunctionVectorMaterialTempl(), Coupleable::getDefaultVectorValue(), MooseVariableFE< RealEigenVector >::getElementalValue(), MultiAppTransfer::getFromBoundingBoxes(), MultiAppGeneralFieldTransfer::getMaxToProblemsBBoxDimensions(), MultiAppGeneralFieldTransfer::getRestrictedFromBoundingBoxes(), ArrayFunctionIC::gradient(), Moose::FV::greenGaussGradient(), Moose::FV::greenGaussGradient(), Moose::FV::greenGaussGradient(), Moose::FV::harmonicInterpolation(), MooseAppCoordTransform::hasScalingOrRotationTransformation(), Moose::Kokkos::Real33::identity(), CartesianGridDivision::initialize(), ParsedDownSelectionPositions::initialize(), PropertyReadFile::initVoronoiCenterPoints(), Moose::Kokkos::Real33::inverse(), MooseUtils::isFinitePoint(), MultiAppCoordTransform::isIdentity(), NestedSolveTempl< is_ad >::isRelSmall(), PointListAdaptor< PointObject >::kdtree_distance(), PointListAdaptor< PointObject >::kdtree_get_pt(), Moose::Kokkos::ArrayBase< T, dimension, index_type >::n(), Moose::Kokkos::JaggedArrayInnerData< T, inner, layout >::n(), Moose::Kokkos::JaggedArray< T, inner, outer, index_type, layout >::n(), Moose::Kokkos::MaterialPropertyValueBase< T, dimension >::n(), MathUtils::normSquared(), ResetDisplacedMeshThread::onNode(), SecondaryNeighborhoodThread::operator()(), Moose::Kokkos::Thread< thread_id_type, max_dimension >::operator()(), Moose::Kokkos::JaggedArray< T, inner, outer, index_type, layout >::operator()(), Moose::Kokkos::operator*(), ColumnMajorMatrixTempl< T >::operator*(), Moose::Kokkos::Real33::operator*=(), Moose::Kokkos::Real33::operator+=(), ColumnMajorMatrixTempl< T >::operator+=(), Moose::Kokkos::Real33::operator=(), Moose::Kokkos::Real33::operator=(), Moose::Kokkos::Real33::operator=(), ColumnMajorMatrixTempl< T >::operator=(), Moose::Kokkos::JaggedArray< T, inner, outer, index_type, layout >::operator[](), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), PointIndexedMap::PointIndexedMap(), PropertyReadFile::PropertyReadFile(), Moose::Kokkos::JaggedArray< T, inner, outer, index_type, layout >::reserve(), Moose::Kokkos::Thread< thread_id_type, max_dimension >::resize(), sideIntersectedByLine(), Moose::Kokkos::Thread< thread_id_type, max_dimension >::size(), MultiApp::transformBoundingBox(), Moose::Kokkos::Real33::transpose(), BoundingBoxIC::value(), and MoveNodesByParsedExpressionModifier::writeOutputs().

eigen_problem_type_to_enum

std::map<std::string, EigenProblemType> Moose::eigen_problem_type_to_enum

Definition at line 27 of file Conversion.C.

Referenced by initEigenProlemType(), and stringToEnum< EigenProblemType >().

eigen_solve_type_to_enum

std::map<std::string, EigenSolveType> Moose::eigen_solve_type_to_enum

Definition at line 26 of file Conversion.C.

Referenced by initEigenSolveType(), and stringToEnum< EigenSolveType >().

EMPTY_BLOCK_IDS

const std::set<SubdomainID> Moose::EMPTY_BLOCK_IDS = {}

Definition at line 737 of file MooseTypes.h.

{};

EMPTY_BOUNDARY_IDS

const std::set<BoundaryID> Moose::EMPTY_BOUNDARY_IDS = {}

Definition at line 738 of file MooseTypes.h.

{};

execute_flags

ExecFlagEnum Moose::execute_flags

extern

Storage for the registered execute flags.

This is needed for the ExecuteMooseObjectWarehouse to create the necessary storage containers on a per flag basis. This isn't something that should be used by application developers.

interrupt_signal_number

volatile std::sig_atomic_t Moose::interrupt_signal_number = 0

Used by the signal handler to determine if we should write a checkpoint file out at any point during operation.

Definition at line 924 of file Moose.C.

Referenced by Output::outputStep(), Checkpoint::shouldOutput(), and SigHandler().

INVALID_BLOCK_ID

const SubdomainID Moose::INVALID_BLOCK_ID = libMesh::Elem::invalid_subdomain_id

Definition at line 20 of file MooseTypes.C.

Referenced by FEProblemBase::checkProblemIntegrity(), ComputeFullJacobianThread::computeOnInternalFace(), ComputeResidualThread::computeOnInternalFace(), MultiAppGeometricInterpolationTransfer::computeTransformation(), MooseMeshUtils::convertBlockToMesh(), SubdomainsDivision::divisionIndex(), ElementSubdomainModifier::execute(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), ElementSubdomainModifierBase::gatherMovingBoundaryChangesHelper(), RenameBlockGenerator::generate(), RenumberBySubdomainGenerator::generate(), XYMeshLineCutter::generate(), MooseMeshUtils::getSubdomainID(), TimedSubdomainModifier::getSubdomainIDAndCheck(), MooseMeshUtils::hasSubdomainID(), ElementSubdomainModifierBase::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), AttribSubdomains::isMatch(), FaceInfo::neighborSubdomainID(), ComputeLinearFVElementalThread::operator()(), ComputeLinearFVFaceThread::operator()(), ComputeJacobianForScalingThread::operator()(), ThreadedFaceLoop< RangeType >::operator()(), ThreadedElementLoopBase< RangeType >::operator()(), ComputeLinearFVFaceThread::printBlockExecutionInformation(), ComputeFVFluxThread< RangeType, AttributeTagType >::printBlockExecutionInformation(), ComputeFVFluxThread< RangeType, AttributeTagType >::printBoundaryExecutionInformation(), MooseMeshXYCuttingUtils::quadToTriOnLine(), MooseMeshXYCuttingUtils::quasiTriElementsFixer(), PiecewiseByBlockLambdaFunctor< T >::setFunctor(), and MeshTriangulationUtils::triangulateWithDelaunay().

INVALID_BOUNDARY_ID

const BoundaryID Moose::INVALID_BOUNDARY_ID = libMesh::BoundaryInfo::invalid_id

Definition at line 22 of file MooseTypes.C.

Referenced by BreakMeshByBlockGenerator::addInterface(), MultiAppNearestNodeTransfer::execute(), SidesetAroundSubdomainUpdater::executeOnExternalSide(), BreakMeshByBlockGenerator::generate(), BreakMeshByElementGenerator::generate(), RefineSidesetGenerator::generate(), RenameBoundaryGenerator::generate(), PatternedMeshGenerator::generate(), MooseMeshUtils::getBoundaryID(), MooseMeshUtils::hasBoundaryID(), MooseMeshUtils::hasBoundaryName(), NonlinearThread::onInternalSide(), GhostPrimaryFace::operator()(), GhostBoundary::operator()(), MooseMesh::prepare(), NonlinearThread::prepareFace(), SidesetAroundSubdomainUpdater::processSide(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), Moose::PeriodicBCHelper::setupManualPeriodicBoundaries(), SidesetAroundSubdomainUpdater::validParams(), and XYMeshLineCutter::XYMeshLineCutter().

INVALID_PROCESSOR_ID

const processor_id_type Moose::INVALID_PROCESSOR_ID = libMesh::DofObject::invalid_processor_id

Definition at line 18 of file MooseTypes.C.

invalid_size_t

constexpr std::size_t Moose::invalid_size_t = std::numeric_limits<std::size_t>::max()

inlineconstexpr

Value for invalid size_t indices.

Definition at line 178 of file Moose.h.

INVALID_TAG_ID

const TagID Moose::INVALID_TAG_ID = static_cast<TagID>(-1)

Definition at line 23 of file MooseTypes.C.

Referenced by MooseVariableDataBase< OutputType >::assignNodalValue(), PicardSolve::saveVariableValues(), SecantSolve::saveVariableValues(), and SteffensenSolve::saveVariableValues().

INVALID_TAG_TYPE_ID

const TagTypeID Moose::INVALID_TAG_TYPE_ID = static_cast<TagTypeID>(-1)

Definition at line 24 of file MooseTypes.C.

line_search_type_to_enum

std::map<std::string, LineSearchType> Moose::line_search_type_to_enum

Definition at line 29 of file Conversion.C.

Referenced by initLineSearchType(), and stringToEnum< LineSearchType >().

mffd_type_to_enum

std::map<std::string, MffdType> Moose::mffd_type_to_enum

Definition at line 31 of file Conversion.C.

Referenced by initMffdType(), and stringToEnum< MffdType >().

OLD_SOLUTION_TAG

const TagName Moose::OLD_SOLUTION_TAG = "SOLUTION_STATE_1"

Definition at line 26 of file MooseTypes.C.

Referenced by SystemBase::oldSolutionStateVectorName(), Coupleable::requestStates(), and MooseVariableDataBase< OutputType >::stateToTagHelper().

OLDER_SOLUTION_TAG

const TagName Moose::OLDER_SOLUTION_TAG = "SOLUTION_STATE_2"

Definition at line 27 of file MooseTypes.C.

Referenced by SystemBase::oldSolutionStateVectorName(), Coupleable::requestStates(), and MooseVariableDataBase< OutputType >::stateToTagHelper().

perf_log

libMesh::PerfLog Moose::perf_log

extern

Perflog to be used by applications.

If the application prints this in the end they will get performance info.

This is no longer instantiated in the framework and will be removed in the future.

PREVIOUS_MULTIAPP_FP_SOLUTION_TAG

const TagName Moose::PREVIOUS_MULTIAPP_FP_SOLUTION_TAG = "U_PREVIOUS_MULTIAPP_FP"

Definition at line 29 of file MooseTypes.C.

Referenced by PicardSolve::allocateStorage(), SecantSolve::allocateStorage(), and SystemBase::oldSolutionStateVectorName().

PREVIOUS_MULTISYSTEM_FP_SOLUTION_TAG

const TagName Moose::PREVIOUS_MULTISYSTEM_FP_SOLUTION_TAG = "U_PREVIOUS_MULTISYSTEM_FP"

Definition at line 30 of file MooseTypes.C.

Referenced by SystemBase::oldSolutionStateVectorName().

PREVIOUS_NL_SOLUTION_TAG

const TagName Moose::PREVIOUS_NL_SOLUTION_TAG = "U_PREVIOUS_NL_NEWTON"

Definition at line 28 of file MooseTypes.C.

Referenced by FEProblemBase::computePostCheck(), FEProblemBase::needsPreviousNewtonIteration(), FEProblemBase::needsPreviousNewtonIteration(), SystemBase::oldSolutionStateVectorName(), NonlinearSystemBase::setPreviousNewtonSolution(), SystemBase::solutionPreviousNewton(), SystemBase::solutionPreviousNewton(), and MooseVariableDataBase< OutputType >::stateToTagHelper().

rm_type_to_enum

std::map<std::string, RelationshipManagerType> Moose::rm_type_to_enum

Definition at line 32 of file Conversion.C.

Referenced by initRMType(), and stringToEnum< RelationshipManagerType >().

show_multiple

bool Moose::show_multiple = false

Set to false (the default) to display an error message only once for each error call code location (as opposed to every time the code is executed).

Definition at line 925 of file Moose.C.

SOLUTION_DOT_TAG

const TagName Moose::SOLUTION_DOT_TAG = "u_dot_factor"

Definition at line 31 of file MooseTypes.C.

SOLUTION_DOTDOT_TAG

const TagName Moose::SOLUTION_DOTDOT_TAG = "u_dotdot_factor"

Definition at line 32 of file MooseTypes.C.

SOLUTION_TAG

const TagName Moose::SOLUTION_TAG = "SOLUTION"

Definition at line 25 of file MooseTypes.C.

Referenced by FEProblemBase::createTagSolutions(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MooseVariableDataBase< OutputType >::MooseVariableDataBase(), SolverSystem::setSolution(), and MooseVariableDataBase< OutputType >::stateToTagHelper().

solve_type_to_enum

std::map<std::string, SolveType> Moose::solve_type_to_enum

Definition at line 25 of file Conversion.C.

Referenced by initSolveType(), and stringToEnum< SolveType >().

time_integrator_to_enum

std::map<std::string, TimeIntegratorType> Moose::time_integrator_to_enum

Definition at line 30 of file Conversion.C.

Referenced by initTimeIntegratorsType(), and stringToEnum< TimeIntegratorType >().

which_eigen_pairs_to_enum

std::map<std::string, WhichEigenPairs> Moose::which_eigen_pairs_to_enum

Definition at line 28 of file Conversion.C.

Referenced by initWhichEigenPairs(), and stringToEnum< WhichEigenPairs >().