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
	DataFileUtils
	FV
	internal
	MFEM
	Mortar
	PetscSupport
	SlepcSupport

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< MooseUtils::SemidynamicVector< T, N, value_init > >
struct	ADType< Point >
struct	ADType< RankFourTensor >
struct	ADType< RankThreeTensor >
struct	ADType< RankTwoTensor >
struct	ADType< Real >
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	Builder
	Parses MOOSE input using HIT/WASP. More...
class	Capabilities
	This singleton class holds a registry for capabilities supported by the current app. More...
class	ConstantFunctor
	Class template for creating constant functors. 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	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	PassKey
class	RawValueFunctor
class	ScopedCommSwapper
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 > >
struct	StateArg
	State argument for evaluating functors. More...
class	TorchScriptModule
struct	TypeList
	Helper structure to hold a list of types. 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. More...

Enumerations
enum	FunctorEvaluationKind { FunctorEvaluationKind::Value, FunctorEvaluationKind::Gradient, FunctorEvaluationKind::Dot, FunctorEvaluationKind::GradDot }
	An enumeration of possible functor evaluation kinds. More...
enum	SolutionState : int { Current = 0, Old = 1, Older = 2, PreviousNL = -1 }
enum	SolutionIterationType : unsigned short { SolutionIterationType::Time = 0, SolutionIterationType::Nonlinear }
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	ElementType : unsigned int { ElementType::Element = DGResidualType::Element, ElementType::Neighbor = DGResidualType::Neighbor, ElementType::Lower = DGResidualType::Neighbor + 1 }
enum	MortarType : unsigned int { MortarType::Secondary = static_cast<unsigned int>(Moose::ElementType::Element), MortarType::Primary = static_cast<unsigned int>(Moose::ElementType::Neighbor), MortarType::Lower = static_cast<unsigned int>(Moose::ElementType::Lower) }
enum	ComputeType { ComputeType::Residual, ComputeType::Jacobian, ComputeType::ResidualAndJacobian }
	The type of nonlinear computation being performed. More...
enum	RESTARTABLE_FILTER : unsigned char { RESTARTABLE_FILTER::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	RelationshipManagerType : unsigned char { RelationshipManagerType::DEFAULT = 0, RelationshipManagerType::GEOMETRIC = 1 << 0, RelationshipManagerType::ALGEBRAIC = 1 << 1, RelationshipManagerType::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	FEBackend { FEBackend::LibMesh, FEBackend::MFEM }

Functions
InputParameters	commonAdaptivityParams ()
bool	colorConsole ()
	Returns whether Console coloring is turned on (default: true). More...
bool	setColorConsole (bool use_color, bool force=false)
	Turns color escape sequences on/off for info written to stdout. More...
void	registerAll (Factory &f, ActionFactory &af, Syntax &s)
	Register objects that are in MOOSE. More...
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. More...
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. More...
StateArg	currentState ()
StateArg	oldState ()
StateArg	previousNonlinearState ()
std::shared_ptr< MooseApp >	createMooseApp (const std::string &default_app_type, int argc, char *argv[])
	Create a MooseApp from command-line arguments. More...
template<typename DefaultAppType >
int	main (int argc, char *argv[])
	Initialize, create and run a MooseApp. More...
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. More...
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. More...
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. More...
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. More...
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. More...
bool	doDerivatives (const SubProblem &subproblem, const SystemBase &sys)
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 More...
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. More...
std::string	stringify (const EigenSolveType &t)
	Convert eigen solve type into human readable string. More...
std::string	stringify (const VarFieldType &t)
	Convert variable field type into human readable string. More...
std::string	stringify (const std::string &s)
	Add no-op stringify if the argument already is a string (must use overloading) More...
std::string	stringify (libMesh::FEFamily f)
	Convert FEType from libMesh into string. More...
std::string	stringify (SolutionIterationType t)
	Convert SolutionIterationType into string. More...
std::string	stringify (ElementType t)
	Convert ElementType into string. More...
std::string	stringify (libMesh::ElemType t)
	Convert the libmesh ElemType into string. More...
template<typename T , typename U >
std::string	stringify (const std::pair< T, U > &p, const std::string &delim=":")
	Add pair stringify to support maps. More...
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. More...
std::string	stringifyExact (Real)
	Stringify Reals with enough precision to guarantee lossless Real -> string -> Real roundtrips. More...
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. More...
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. More...
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. More...
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	getExecutablePath ()
	This function returns the PATH of the running executable. More...
std::string	getExecutableName ()
	This function returns the name of the running executable. More...
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. More...
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. More...
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. More...
void	hash_combine (std::size_t &)
	Used for hash function specialization for Attribute objects. More...
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). More...
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. More...
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. More...
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<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. More...
	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. More...
template<template< typename, int > class L, typename... Ts, typename... As>
void	typeLoop (TypeList< Ts... >, As... args)
	Type loop. More...
template<typename T >
void	initDofIndices (T &data, const Elem &elem)
void	associateSyntaxInner (Syntax &syntax, ActionFactory &action_factory)
bool	isSectionActive (std::string path, hit::Node *root)
std::vector< std::string >	findSimilar (std::string param, std::vector< std::string > options)
template<>
void	Builder::setScalarParameter< ReporterName, std::string > (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< ReporterName > *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	Builder::setVectorParameter< ReporterName, std::string > (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< ReporterName >> *param, bool in_global, GlobalParamsAction *global_block)
template<>
void	Builder::setVectorParameter< CLIArgString, std::string > (const std::string &full_name, const std::string &short_name, InputParameters::Parameter< std::vector< CLIArgString >> *param, bool in_global, GlobalParamsAction *global_block)
template<typename T >
bool	toBool (const std::string &, T &)
template<>
bool	toBool< bool > (const std::string &s, bool &val)
void	compute_linear_system (libMesh::EquationSystems &es, const std::string &system_name)
void	assemble_matrix (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<>
EigenSolveType	stringToEnum< EigenSolveType > (const std::string &s)
template<>
EigenProblemType	stringToEnum< EigenProblemType > (const std::string &s)
template<>
WhichEigenPairs	stringToEnum< WhichEigenPairs > (const std::string &s)
template<>
MffdType	stringToEnum< MffdType > (const std::string &s)
Point	toPoint (const std::vector< Real > &pos)
	Convert point represented as std::vector into Point. More...
void	findElementsIntersectedByPlane (const libMesh::Plane &plane, const MeshBase &mesh, std::vector< const Elem *> &intersected_elems)
std::string	getExec ()
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. More...
int	sideNeighborIsOn (const Elem *elem, const Elem *neighbor)
	Returns the side number for elem that neighbor is on. More...
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. More...
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. More...
int	interrupt_signal_number = 0
	Used by the signal handler to determine if we should write a checkpoint file out at any point during operation. More...
bool	show_trace = true
	Set to true (the default) to print the stack trace with error and warning messages - false to omit it. More...
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). More...
libMesh::PerfLog	perf_log
	Perflog to be used by applications. More...
bool	_trap_fpe
	Variable indicating whether we will enable FPE trapping for this run. More...
bool	_warnings_are_errors = false
	Variable to toggle any warning into an error (includes deprecated code warnings) More...
bool	_deprecated_is_error = false
	Variable to toggle only deprecated warnings as errors. More...
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. More...
bool	_throw_on_warning = false
	Variable to turn on exceptions during mooseWarning(), should only be used in MOOSE unit tests. More...
ExecFlagEnum	execute_flags
	Storage for the registered execute flags. More...
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). More...
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. More...
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"
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 644 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 989 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 703 of file MooseTypes.h.

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

ComputeType

enum Moose::ComputeType

strong

The type of nonlinear computation being performed.

Enumerator
Residual
Jacobian
ResidualAndJacobian

Definition at line 780 of file MooseTypes.h.

{
  Residual,
  Jacobian,
  ResidualAndJacobian
};

ConstraintFormulationType

enum Moose::ConstraintFormulationType

Type of constraint formulation.

Enumerator
Penalty
Kinematic

Definition at line 917 of file MooseTypes.h.

{
  Penalty,
  Kinematic
};

ConstraintJacobianType

enum Moose::ConstraintJacobianType

Enumerator
SecondarySecondary
SecondaryPrimary
PrimarySecondary
PrimaryPrimary
LowerLower
LowerSecondary
LowerPrimary
SecondaryLower
PrimaryLower

Definition at line 796 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 737 of file MooseTypes.h.

{
  SIDE_PRIMARY,
  SIDE_SECONDARY
};

ConstraintType

enum Moose::ConstraintType

Enumerator
Secondary
Primary

Definition at line 757 of file MooseTypes.h.

{
  Secondary = Element,
  Primary = Neighbor
};

CoordinateSystemType

enum Moose::CoordinateSystemType : int

Enumerator
COORD_XYZ
COORD_RZ
COORD_RSPHERICAL

Definition at line 809 of file MooseTypes.h.

                          : int
{
  COORD_XYZ = 0,
  COORD_RZ,
  COORD_RSPHERICAL
};

CouplingType

enum Moose::CouplingType

Enumerator
COUPLING_DIAG
COUPLING_FULL
COUPLING_CUSTOM

Definition at line 730 of file MooseTypes.h.

{
  COUPLING_DIAG,
  COUPLING_FULL,
  COUPLING_CUSTOM
};

DGJacobianType

enum Moose::DGJacobianType

Enumerator
ElementElement
ElementNeighbor
NeighborElement
NeighborNeighbor

Definition at line 749 of file MooseTypes.h.

{
  ElementElement,
  ElementNeighbor,
  NeighborElement,
  NeighborNeighbor
};

DGResidualType

enum Moose::DGResidualType

Enumerator
Element
Neighbor

Definition at line 743 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 870 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 854 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 Moose::ElementType : unsigned int

strong

Enumerator
Element
Neighbor
Lower

Definition at line 763 of file MooseTypes.h.

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

FEBackend

enum Moose::FEBackend

strong

Enumerator
LibMesh
MFEM

Definition at line 1199 of file MooseTypes.h.

{
  LibMesh
#ifdef MOOSE_MFEM_ENABLED
  ,
  MFEM
#endif
};

FunctorEvaluationKind

enum 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 248 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 925 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 691 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 942 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 830 of file MooseTypes.h.

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

MortarType

enum Moose::MortarType : unsigned int

strong

Enumerator
Secondary
Primary
Lower

Definition at line 770 of file MooseTypes.h.

                      : 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)
};

PatchUpdateType

enum Moose::PatchUpdateType

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

Enumerator
Never
Always
Auto
Iteration

Definition at line 952 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 819 of file MooseTypes.h.

{
  PCS_LEFT,
  PCS_RIGHT,
  PCS_SYMMETRIC,
  PCS_DEFAULT 
};

RelationshipManagerType

enum Moose::RelationshipManagerType : unsigned char

strong

Main types of Relationship Managers.

Enumerator
DEFAULT
GEOMETRIC
ALGEBRAIC
COUPLING

Definition at line 963 of file MooseTypes.h.

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

RESTARTABLE_FILTER

enum 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 791 of file MooseTypes.h.

                              : unsigned char
{
  RECOVERABLE
};

RMSystemType

enum Moose::RMSystemType

Enumerator
NONLINEAR
AUXILIARY
NONE

Definition at line 971 of file MooseTypes.h.

{
  NONLINEAR,
  AUXILIARY,
  NONE
};

SolutionIterationType

enum Moose::SolutionIterationType : unsigned short

strong

Enumerator
Time
Nonlinear

Definition at line 241 of file MooseTypes.h.

                                 : unsigned short
{
  Time = 0,
  Nonlinear
};

SolutionState

enum Moose::SolutionState : int

Enumerator
Current
Old
Older
PreviousNL

Definition at line 233 of file MooseTypes.h.

                   : int
{
  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 842 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 902 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 721 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 714 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 978 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 884 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 79 of file Moose.C.

Referenced by associateSyntaxInner().

{
  // 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);

  registerMooseObjectTask("add_variable",                 MooseVariableBase,         false);
  registerMooseObjectTask("add_aux_variable",             MooseVariableBase,         false);
  registerMooseObjectTask("add_elemental_field_variable", 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_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_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_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("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("chain_control_setup", 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_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_periodic_bc)"
                           "(add_user_object, add_corrector, add_mesh_modifier)"
                           "(add_distribution)"
                           "(add_sampler)"
                           "(setup_function_complete)"
                           "(setup_adaptivity)"
                           "(set_adaptivity_options)"
                           "(add_ic, add_fv_ic)"
                           "(add_constraint, add_field_split)"
                           "(add_preconditioning)"
                           "(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_positions)"
                           "(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)"
                           "(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_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)"
                           "(check_output)"
                           "(check_integrity)"
                           "(create_application_block)");
  // clang-format on

#ifdef MOOSE_MFEM_ENABLED
  registerTask("add_mfem_problem_operator", true);
  addTaskDependency("add_mfem_problem_operator", "init_mesh");
  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_kernel", "add_mfem_problem_operator");

  // 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");
  addTaskDependency("add_variable", "add_mfem_fespaces");
  addTaskDependency("add_aux_variable", "add_mfem_fespaces");
  addTaskDependency("add_elemental_field_variable", "add_mfem_fespaces");
  addTaskDependency("add_kernel", "add_mfem_fespaces");

  // set mesh FE space
  registerTask("set_mesh_fe_space", true);
  addTaskDependency("set_mesh_fe_space", "add_variable");
  addTaskDependency("set_mesh_fe_space", "init_mesh");

  // add preconditioning.
  registerMooseObjectTask("add_mfem_preconditioner", MFEMSolverBase, false);
  addTaskDependency("add_mfem_preconditioner", "add_mfem_problem_operator");
  addTaskDependency("add_mfem_preconditioner", "add_variable");

  // add solver.
  registerMooseObjectTask("add_mfem_solver", MFEMSolverBase, true);
  addTaskDependency("add_mfem_solver", "add_mfem_preconditioner");
  addTaskDependency("add_mfem_solver", "add_mfem_problem_operator");
#endif

  registerTask("parse_neml2", /*required=*/false);
  addTaskDependency("add_material", "parse_neml2");
  addTaskDependency("add_user_object", "parse_neml2");
}

adOffset() [1/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 79 of file ADUtils.h.

Referenced by adOffset(), and globalDofIndexToDerivative().

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

adOffset() [2/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 109 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);
}

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 108 of file IndirectSort.h.

Referenced by ElementMaterialSampler::sortVecs().

{
  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() [1/2]

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

Referenced by EigenProblem::init().

assemble_matrix() [2/2]

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

Definition at line 44 of file NonlinearEigenSystem.C.

{
  EigenProblem * p = es.parameters.get<EigenProblem *>("_eigen_problem");
  CondensedEigenSystem & eigen_system = es.get_system<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(static_cast<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;
  }
}

associateSyntax()

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

Definition at line 720 of file Moose.C.

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

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 503 of file Moose.C.

Referenced by associateSyntax(), and registerAll().

{
  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");

  // 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
  registerSyntax("MaterialDerivativeTestAction", "Debug/MaterialDerivativeTest/*");

  registerSyntax("ProjectedStatefulMaterialStorageAction", "ProjectedStatefulMaterialStorage/*");

  // Application Block System
  registerSyntax("CreateApplicationBlockAction", "Application");

#ifdef MOOSE_MFEM_ENABLED
  registerSyntaxTask("AddMFEMSubMeshAction", "SubMeshes/*", "add_mfem_submeshes");
  registerSyntaxTask("AddMFEMFESpaceAction", "FESpaces/*", "add_mfem_fespaces");
  registerSyntaxTask("AddMFEMPreconditionerAction", "Preconditioner/*", "add_mfem_preconditioner");
  registerSyntaxTask("AddMFEMSolverAction", "Solver", "add_mfem_solver");
#endif

  registerSyntax("NEML2ActionCommon", "NEML2");
  registerSyntax("NEML2Action", "NEML2/*");

  addActionTypes(syntax);
}

Builder::setScalarParameter< ReporterName, std::string >()

template<>

void Moose::Builder::setScalarParameter< ReporterName, std::string >	(	const std::string &	full_name,
		const std::string &	short_name,
		InputParameters::Parameter< ReporterName > *	param,
		bool	in_global,
		GlobalParamsAction *	global_block
	)

Definition at line 2090 of file Builder.C.

{
  std::vector<std::string> names =
      MooseUtils::rsplit(root()->param<std::string>(full_name), "/", 2);
  if (names.size() != 2)
    _errmsg += hit::errormsg(root()->find(full_name),
                             "The supplied name ReporterName '",
                             full_name,
                             "' must contain the '/' delimiter.");
  else
    param->set() = ReporterName(names[0], names[1]);
}

Builder::setVectorParameter< CLIArgString, std::string >()

template<>

void Moose::Builder::setVectorParameter< CLIArgString, std::string >	(	const std::string &	full_name,
		const std::string &	short_name,
		InputParameters::Parameter< std::vector< CLIArgString >> *	param,
		bool	in_global,
		GlobalParamsAction *	global_block
	)

Definition at line 2315 of file Builder.C.

{
  // Parsed as a vector of string, the vectors parameters are being cut
  auto rnames = root()->param<std::vector<std::string>>(full_name);
  param->set().resize(rnames.size()); // slightly oversized if vectors have been split

  // Skip empty parameter
  if (rnames.empty())
    return;

  // Re-assemble vector parameters
  unsigned int i_param = 0;
  bool vector_param_detected = false;
  for (unsigned int i = 0; i < rnames.size(); ++i)
  {
    // Look for a quote, both types
    std::vector<std::string> double_split =
        MooseUtils::rsplit(rnames[i], "\"", std::numeric_limits<std::size_t>::max());
    std::vector<std::string> single_split =
        MooseUtils::rsplit(rnames[i], "\'", std::numeric_limits<std::size_t>::max());
    if (double_split.size() + single_split.size() >= 3)
      // Either entering or exiting a vector parameter (>3 is entering another vector)
      // Even and >2 number of quotes means both finished and started another vector parameter
      if ((double_split.size() + single_split.size()) % 2 == 1)
        vector_param_detected = !vector_param_detected;

    // We're building a vector parameters, just append the text, rebuild the spaces
    if (vector_param_detected)
      param->set()[i_param] += rnames[i] + ' ';
    else
    {
      param->set()[i_param] += rnames[i];
      i_param++;
    }
  }
  // Use actual size after re-forming vector parameters
  param->set().resize(i_param);
}

Builder::setVectorParameter< ReporterName, std::string >()

template<>

void Moose::Builder::setVectorParameter< ReporterName, std::string >	(	const std::string &	full_name,
		const std::string &	short_name,
		InputParameters::Parameter< std::vector< ReporterName >> *	param,
		bool	in_global,
		GlobalParamsAction *	global_block
	)

Definition at line 2290 of file Builder.C.

{
  auto rnames = root()->param<std::vector<std::string>>(full_name);
  param->set().resize(rnames.size());

  for (unsigned int i = 0; i < rnames.size(); ++i)
  {
    std::vector<std::string> names = MooseUtils::rsplit(rnames[i], "/", 2);
    if (names.size() != 2)
      _errmsg += hit::errormsg(root()->find(full_name),
                               "The supplied name ReporterName '",
                               rnames[i],
                               "' must contain the '/' delimiter.");
    else
      param->set()[i] = ReporterName(names[0], names[1]);
  }
}

colorConsole()

bool Moose::colorConsole

(

)

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

Definition at line 744 of file Moose.C.

{
  return _color_console;
}

commonAdaptivityParams()

InputParameters Moose::commonAdaptivityParams

(

)

Definition at line 23 of file SetAdaptivityOptionsAction.C.

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

{
  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.addParam<Real>("start_time",
                        -std::numeric_limits<Real>::max(),
                        "The time that adaptivity will be active after.");
  params.addParam<Real>("stop_time",
                        std::numeric_limits<Real>::max(),
                        "The time after which adaptivity will no longer be active.");
  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");
  params.addParam<bool>("switch_h_to_p_refinement", false, "True to perform p-refinement");
  return params;
}

compute_bounds()

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

Definition at line 48 of file NonlinearSystem.C.

Referenced by NonlinearSystem::NonlinearSystem().

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

compute_jacobian()

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

Definition at line 38 of file NonlinearSystem.C.

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

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

compute_linear_system()

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

Definition at line 64 of file LinearSystem.C.

Referenced by LinearSystem::LinearSystem().

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

compute_nearnullspace()

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

Definition at line 75 of file NonlinearSystem.C.

Referenced by NonlinearSystem::NonlinearSystem().

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

compute_nullspace()

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

Definition at line 58 of file NonlinearSystem.C.

Referenced by NonlinearSystem::NonlinearSystem().

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

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 83 of file NonlinearSystem.C.

Referenced by NonlinearSystem::solve().

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

compute_transpose_nullspace()

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

Definition at line 66 of file NonlinearSystem.C.

Referenced by NonlinearSystem::NonlinearSystem().

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

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::shared_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.

Referenced by main().

{
  // 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
  CommandLine cl(argc, argv);
  cl.parse();
  auto command_line_params = emptyInputParameters();
  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.");

  // Parse the input file; this will set Parser::getAppType() if Application/type= is found
  const auto & input_filenames = command_line_params.get<std::vector<std::string>>("input_file");
  auto parser = std::make_unique<Parser>(input_filenames);
  parser->setAppType(default_app_type);
  if (input_filenames.size())
    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(cl).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::createAppShared(argc, argv, std::move(parser));
}

currentState()

StateArg Moose::currentState ( )

inline

Definition at line 151 of file MooseFunctorArguments.h.

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

{
  return {};
}

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 20 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.

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

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

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.

Referenced by MooseVariableData< OutputType >::computeAD(), MooseVariableFE< Real >::computeSolution(), and MooseVariableFE< Real >::evaluate().

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

elementsIntersectedByLine() [1/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< Real >::execute().

elementsIntersectedByLine() [2/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 194 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);
}

elementsIntersectedByPlane() [1/2]

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.

Definition at line 55 of file ElementsIntersectedByPlane.C.

Referenced by ElementsAlongPlane::execute().

{
  // 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() [2/2]

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.

Definition at line 71 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 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.

Referenced by JvarMapInterfaceBase< Kernel >::JvarMapInterfaceBase(), NearestPointIntegralVariablePostprocessor::nearestPointIndex(), NearestPointAverage::nearestPointIndex(), and NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::nearestUserObject().

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

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

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 22 of file MooseLagrangeHelpers.h.

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

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

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 96 of file MooseLagrangeHelpers.h.

Referenced by fe_lagrange_2D_shape_deriv().

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

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 171 of file MooseLagrangeHelpers.h.

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

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

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 378 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()

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 50 of file FindContactPoint.C.

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

{
  // 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;
      }
      catch (libMesh::LogicError & e)
      {
        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;
}

findElementsIntersectedByPlane()

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

Definition at line 26 of file ElementsIntersectedByPlane.C.

Referenced by elementsIntersectedByPlane().

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

findSimilar()

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

Definition at line 97 of file Builder.C.

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

{
  std::vector<std::string> candidates;
  if (options.size() == 0)
    return candidates;

  int mindist = MooseUtils::levenshteinDist(options[0], param);
  for (auto & opt : options)
  {
    int dist = MooseUtils::levenshteinDist(opt, param);
    // magic number heuristics to get similarity distance cutoff
    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;
}

getExec()

std::string Moose::getExec

(

)

Definition at line 24 of file ExecutablePath.C.

Referenced by getExecutableName(), and getExecutablePath().

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

getExecutableName()

std::string Moose::getExecutableName

(

)

This function returns the name of the running executable.

There is not a portable way to do this function implements this function for Mac OS X and Linux boxes containing a normal /proc tree

Definition at line 60 of file ExecutablePath.C.

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

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

getExecutablePath()

std::string Moose::getExecutablePath

(

)

This function returns the PATH of the running executable.

There is not a portable way to do this function implements this function for Mac OS X and Linux boxes containing a normal /proc tree

Definition at line 51 of file ExecutablePath.C.

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

{
  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) + "/";
}

globalADIndexing()

bool Moose::globalADIndexing ( )

inline

Whether we are using global AD indexing.

Definition at line 29 of file ADUtils.h.

Referenced by FEProblemBase::init().

{
  return true;
}

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.

Referenced by globalDofIndexToDerivative().

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

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 136 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(), PointIndexedMap::hash_point::operator()(), moose::internal::SoltionInvalidityNameHash::operator()(), std::hash< std::pair< S, T > >::operator()(), std::hash< Attribute >::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 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)...);
}

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 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)...);
}

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.

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

{
  // 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
  std::sort(b.begin(), b.end(), ic);
}

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 89 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
  std::sort(b.begin(), b.end(), ic);
}

initCoordinateSystemType()

void Moose::initCoordinateSystemType

(

)

Definition at line 37 of file Conversion.C.

Referenced by stringToEnum< CoordinateSystemType >().

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

initDofIndices()

template<typename T >

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

Definition at line 47 of file MooseVariableDataFV.h.

Referenced by MooseVariableDataLinearFV< OutputType >::computeValues(), MooseVariableDataFV< OutputType >::computeValues(), MooseVariableDataLinearFV< OutputType >::dofIndices(), MooseVariableDataFV< OutputType >::dofIndices(), MooseVariableFV< Real >::getElemValue(), MooseVariableFV< Real >::getValue(), MooseVariableDataLinearFV< OutputType >::initDofIndices(), MooseVariableDataFV< OutputType >::initDofIndices(), and MooseVariableDataFV< OutputType >::prepareIC().

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

initEigenProlemType()

void Moose::initEigenProlemType

(

)

Definition at line 78 of file Conversion.C.

Referenced by stringToEnum< EigenProblemType >().

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

initEigenSolveType()

void Moose::initEigenSolveType

(

)

Definition at line 61 of file Conversion.C.

Referenced by stringToEnum< EigenSolveType >().

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

initial_condition()

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

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.

Referenced by indirectSort().

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

initLineSearchType()

void Moose::initLineSearchType

(

)

Definition at line 112 of file Conversion.C.

Referenced by stringToEnum< LineSearchType >().

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

initMffdType()

void Moose::initMffdType

(

)

Definition at line 145 of file Conversion.C.

Referenced by stringToEnum< MffdType >().

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

initRMType()

void Moose::initRMType

(

)

Definition at line 155 of file Conversion.C.

Referenced by stringToEnum< RelationshipManagerType >().

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

initSolveType()

void Moose::initSolveType

(

)

Definition at line 48 of file Conversion.C.

Referenced by stringToEnum< SolveType >().

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

initTimeIntegratorsType()

void Moose::initTimeIntegratorsType

(

)

Definition at line 130 of file Conversion.C.

Referenced by stringToEnum< TimeIntegratorType >().

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

initWhichEigenPairs()

void Moose::initWhichEigenPairs

(

)

Definition at line 93 of file Conversion.C.

Referenced by stringToEnum< WhichEigenPairs >().

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

isSectionActive()

bool Moose::isSectionActive	(	std::string	path,
		hit::Node *	root
	)

Definition at line 60 of file Builder.C.

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

{
  hit::Node * n = root->find(path);
  while (n)
  {
    hit::Node * section = n->parent();
    if (section)
    {
      auto actives = section->find("active");
      auto inactives = section->find("inactive");

      // only check current level, not nested ones
      if (actives && actives->type() == hit::NodeType::Field && actives->parent() == section)
      {
        auto vars = section->param<std::vector<std::string>>("active");
        bool have_var = false;
        for (auto & var : vars)
          if (n->path() == hit::pathNorm(var))
            have_var = true;
        if (!have_var)
          return false;
      }
      // only check current level, not nested ones
      if (inactives && inactives->type() == hit::NodeType::Field && inactives->parent() == section)
      {
        auto vars = section->param<std::vector<std::string>>("inactive");
        for (auto & var : vars)
          if (n->path() == hit::pathNorm(var))
            return false;
      }
    }
    n = section;
  }
  return true;
}

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.

Referenced by removeSubstring().

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

oldState()

StateArg Moose::oldState ( )

inline

Definition at line 157 of file MooseFunctorArguments.h.

Referenced by TransientInterface::determineState().

{
  return {(unsigned int)1};
}

previousNonlinearState()

StateArg Moose::previousNonlinearState ( )

inline

Definition at line 163 of file MooseFunctorArguments.h.

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

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 146 of file RayTracing.C.

Referenced by elementsIntersectedByLine().

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

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 484 of file Moose.C.

Referenced by associateSyntax(), and registerAll().

{
  mooseDeprecated("use registerAll instead of registerActions");
  registerActions(syntax, action_factory, {"MooseApp"});
}

registerActions() [2/2]

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

Definition at line 491 of file Moose.C.

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

registerAll()

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

Register objects that are in MOOSE.

Definition at line 63 of file Moose.C.

Referenced by MooseApp::MooseApp().

{
  registerObjects(f, {"MooseApp"});
  associateSyntaxInner(s, af);
  registerActions(s, af, {"MooseApp"});
  registerAppDataFilePath("moose");
  registerRepository("moose", "github.com/idaholab/moose");
}

registerObjects()

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

Definition at line 73 of file Moose.C.

Referenced by registerAll().

{
  Registry::registerObjectsTo(factory, obj_labels);
}

restrictPointToFace()

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

Definition at line 315 of file FindContactPoint.C.

Referenced by findContactPoint().

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

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	(	RankTwoTensorTempl	,
		&	obj0u, 0u,
		RankTwoTensorTempl< T >::N2
	)

SERIAL_ACCESS_CONST_SIZE() [3/3]

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

SERIAL_ACCESS_DYNAMIC_SIZE()

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

SERIAL_ACCESS_SCALAR() [1/2]

Moose::SERIAL_ACCESS_SCALAR

(

Real

)

SERIAL_ACCESS_SCALAR() [2/2]

Moose::SERIAL_ACCESS_SCALAR

(

ADReal

)

serialAccess()

template<typename T >

SerialAccessRange<T> Moose::serialAccess

(

T &

obj

)

Definition at line 151 of file SerialAccess.h.

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

{
  return SerialAccessRange<T>(obj);
}

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 750 of file Moose.C.

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

{
  _color_console = (isatty(fileno(stdout)) || force) && use_color;
  return _color_console;
}

setSolverDefaults()

void Moose::setSolverDefaults

(

FEProblemBase &

problem

)

Definition at line 727 of file Moose.C.

{
  // May be a touch expensive to create a new DM every time, but probably safer to do it this way
  Moose::PetscSupport::petscSetDefaults(problem);
}

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 36 of file RayTracing.C.

Referenced by recursivelyFindElementsIntersectedByLine().

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

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 117 of file RayTracing.C.

Referenced by recursivelyFindElementsIntersectedByLine().

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

stringify() [1/21]

template<typename T >

std::string Moose::stringify

(

const T &

t

)

conversion to string

Definition at line 64 of file Conversion.h.

Referenced by SetupResidualDebugAction::act(), MaterialDerivativeTestAction::act(), Moose::Capabilities::add(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), PhysicsComponentInterface::addBoundaryConditionsFromComponents(), PhysicsComponentInterface::addInitialConditionsFromComponents(), LinearFVFluxKernel::addMatrixContribution(), ComponentPhysicsInterface::addPhysics(), DiracKernelBase::addPoint(), Action::addRelationshipManager(), MooseVariableData< OutputType >::adGradPhi(), MooseVariableData< OutputType >::adGradPhiFace(), MooseEnum::assign(), AuxKernelTempl< Real >::AuxKernelTempl(), ParsedFunctorMaterialTempl< is_ad >::buildParsedFunction(), CartesianMeshGenerator::CartesianMeshGenerator(), PhysicsBase::checkBlockRestrictionIdentical(), InputParametersChecksUtils< BatchMeshGeneratorAction >::checkBlockwiseConsistency(), MooseMesh::checkCoordinateSystems(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), FEProblemBase::checkExceptionAndStopSolve(), Moose::FunctorBase< libMesh::VectorValue >::checkFace(), MeshGenerator::checkGetMesh(), Steady::checkIntegrity(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), FEProblemBase::checkProblemIntegrity(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), InputParametersChecksUtils< BatchMeshGeneratorAction >::checkTwoDVectorParamsNoRespectiveOverlap(), BlockRestrictable::checkVariable(), InputParametersChecksUtils< BatchMeshGeneratorAction >::checkVectorParamsNoOverlap(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), Moose::SlepcSupport::clearFreeNonlinearPowerIterations(), FEProblemBase::computeUserObjectsInternal(), CopyValueAux::CopyValueAux(), PhysicsBase::copyVariablesFromMesh(), 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(), ParsedMaterialHelper< is_ad >::functionParse(), ExtraNodesetGenerator::generate(), CoarsenBlockGenerator::generate(), AdvancedExtruderGenerator::generate(), ActionWarehouse::getAction(), FunctorBinnedValuesDivision::getBinIndex(), ComputeFVFluxThread< RangeType, AttribMatrixTags >::getBlockNames(), MooseLinearVariableFV< Real >::getElemValue(), MooseVariableFV< Real >::getElemValue(), MeshCoarseningUtils::getFineElementsFromInteriorNode(), SolutionUserObjectBase::getLocalVarIndex(), MooseEnumBase::getRawNames(), MooseApp::getRelationshipManagerInfo(), SystemBase::getScalarVariable(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), SystemBase::getVariable(), SubProblem::getVariableHelper(), Moose::FV::harmonicInterpolation(), ParsedDownSelectionPositions::initialize(), BlockRestrictable::initializeBlockRestrictable(), MultiAppGeneralFieldTransfer::initialSetup(), MatrixTools::inverse(), LeastSquaresFitHistory::LeastSquaresFitHistory(), MultiApp::localApp(), ParsedConvergence::makeParsedFunction(), MeshDivisionAux::MeshDivisionAux(), SystemBase::oldSolutionStateVectorName(), operator<<(), MaterialOutputAction::outputHelper(), Parser::parse(), PatternedMeshGenerator::PatternedMeshGenerator(), 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(), PhysicsBase::reportPotentiallyMissedParameters(), MeshRepairGenerator::separateSubdomainsByElementType(), MooseMesh::setCoordSystem(), Moose::SlepcSupport::setFreeNonlinearPowerIterations(), Moose::SlepcSupport::setNewtonPetscOptions(), Moose::SlepcSupport::setSlepcEigenSolverTolerances(), Split::setup(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), PhysicsBase::shouldCreateVariable(), SystemBase::solutionState(), FEProblemBase::solverSysNum(), EigenProblem::solverTypeString(), FEProblemBase::solverTypeString(), NonlinearSystem::stopSolve(), stringify(), Moose::internal::stringify_variant(), PiecewiseByBlockLambdaFunctor< T >::subdomainErrorMessage(), and FEProblemSolve::validParams().

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

stringify() [2/21]

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

inline

Definition at line 73 of file Conversion.h.

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

stringify() [3/21]

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

inline

Definition at line 80 of file Conversion.h.

{
  return std::to_string(v);
}

stringify() [4/21]

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

inline

Definition at line 85 of file Conversion.h.

{
  return std::to_string(v);
}

stringify() [5/21]

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

inline

Definition at line 90 of file Conversion.h.

{
  return std::to_string(v);
}

stringify() [6/21]

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

inline

Definition at line 95 of file Conversion.h.

{
  return std::to_string(v);
}

stringify() [7/21]

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

inline

Definition at line 100 of file Conversion.h.

{
  return std::to_string(v);
}

stringify() [8/21]

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

inline

Definition at line 105 of file Conversion.h.

{
  return std::to_string(v);
}

stringify() [9/21]

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() [10/21]

std::string Moose::stringify

(

const SolveType &

t

)

Convert solve type into human readable string.

Definition at line 359 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() [11/21]

std::string Moose::stringify

(

const EigenSolveType &

t

)

Convert eigen solve type into human readable string.

Definition at line 378 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() [12/21]

std::string Moose::stringify

(

const VarFieldType &

t

)

Convert variable field type into human readable string.

Definition at line 405 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() [13/21]

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 460 of file Conversion.C.

{
  return s;
}

stringify() [14/21]

std::string Moose::stringify

(

libMesh::FEFamily

f

)

Convert FEType from libMesh into string.

Definition at line 350 of file Conversion.C.

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

stringify() [15/21]

std::string Moose::stringify

(

SolutionIterationType

t

)

Convert SolutionIterationType into string.

Definition at line 424 of file Conversion.C.

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

stringify() [16/21]

std::string Moose::stringify

(

ElementType

t

)

Convert ElementType into string.

Definition at line 438 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() [17/21]

std::string Moose::stringify

(

libMesh::ElemType

t

)

Convert the libmesh ElemType into string.

Definition at line 454 of file Conversion.C.

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

stringify() [18/21]

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() [19/21]

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 174 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() [20/21]

std::string Moose::stringify

(

const Moose::RelationshipManagerType &

t

)

Definition at line 326 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() [21/21]

std::string Moose::stringify

(

const Moose::TimeIntegratorType &

t

)

stringifyExact()

std::string Moose::stringifyExact

(

Real

t

)

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

Definition at line 466 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 >()

template<>

CoordinateSystemType Moose::stringToEnum< CoordinateSystemType >

(

const std::string &

s

)

Definition at line 188 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 233 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 218 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

)

stringToEnum< LineSearchType >()

template<>

LineSearchType Moose::stringToEnum< LineSearchType >

(

const std::string &

s

)

Definition at line 263 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 293 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 175 of file Conversion.C.

Referenced by SetupQuadratureAction::act().

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

stringToEnum< QuadratureType >()

template<>

QuadratureType Moose::stringToEnum< QuadratureType >

(

const std::string &

s

)

Definition at line 168 of file Conversion.C.

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

stringToEnum< RelationshipManagerType >()

template<>

RelationshipManagerType Moose::stringToEnum< RelationshipManagerType >

(

const std::string &

s

)

Definition at line 308 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 >()

template<>

SolveType Moose::stringToEnum< SolveType >

(

const std::string &

s

)

Definition at line 203 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 >()

template<>

TimeIntegratorType Moose::stringToEnum< TimeIntegratorType >

(

const std::string &

s

)

Definition at line 278 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 248 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 734 of file Moose.C.

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

{
  MPI_Comm old_comm = PETSC_COMM_WORLD;
  PETSC_COMM_WORLD = new_comm;
  return old_comm;
}

to_json()

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

Definition at line 151 of file LibtorchArtificialNeuralNet.C.

Referenced by JSONOutput::outputSystemInformation(), ReporterContext< std::vector< T > >::store(), and RestartableData< std::list< T > >::storeJSONValue().

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

toBool()

template<typename T >

bool Moose::toBool	(	const std::string &	,
		T &
	)

Definition at line 1342 of file Builder.C.

Referenced by Moose::Builder::setScalarParameter(), BatchMeshGeneratorAction::setScalarParams(), BatchMeshGeneratorAction::setVectorParams(), and toBool< bool >().

{
  return false;
}

toBool< bool >()

template<>

bool Moose::toBool< bool >	(	const std::string &	s,
		bool &	val
	)

Definition at line 1349 of file Builder.C.

{
  return hit::toBool(s, &val);
}

toPoint()

Point Moose::toPoint

(

const std::vector< Real > &

pos

)

Convert point represented as std::vector into Point.

Parameters

pos	Point represented as a vector

Returns

Converted point

Definition at line 478 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 741 of file Moose.C.

Referenced by colorConsole(), and setColorConsole().

_deprecated_is_error

bool Moose::_deprecated_is_error = false

Variable to toggle only deprecated warnings as errors.

Definition at line 757 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 758 of file Moose.C.

Referenced by InputParameters::finalize(), DataFileInterface::getDataFilePath(), moose::internal::mooseErrorRaw(), MooseServer::parseDocumentForDiagnostics(), 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 759 of file Moose.C.

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

_trap_fpe

bool Moose::_trap_fpe

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 756 of file Moose.C.

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

always_false

template<class... Ts>

constexpr std::false_type Moose::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.

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

Definition at line 590 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(), InitialConditionWarehouse::addObject(), FVInitialConditionWarehouse::addObject(), BlockRestrictable::blockIDs(), BlockRestrictable::blockRestricted(), Assembly::bumpAllQRuleOrder(), Assembly::bumpVolumeQRuleOrder(), ElementSubdomainModifierBase::findReinitializedElemsAndNodes(), 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(), hasBoundary(), BoundaryRestrictable::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

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 230 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 26 of file Conversion.C.

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

dim

constexpr std::size_t Moose::dim = LIBMESH_DIM

static

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 153 of file Moose.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), MFEMProblem::addFunction(), Assembly::Assembly(), Assembly::attachQRuleElem(), Assembly::attachQRuleFace(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), MeshGenerator::buildDistributedMesh(), Assembly::buildFaceFE(), Assembly::buildFaceNeighborFE(), Assembly::buildFE(), Assembly::buildLowerDDualFE(), Assembly::buildLowerDFE(), MooseMesh::buildMeshBaseObject(), MeshGenerator::buildMeshBaseObject(), Assembly::buildNeighborFE(), ParsedFunctorMaterialTempl< is_ad >::buildParsedFunction(), MooseMesh::buildPRefinementAndCoarseningMaps(), MeshGenerator::buildReplicatedMesh(), MooseMesh::buildTypedMesh(), Assembly::buildVectorDualLowerDFE(), Assembly::buildVectorFaceFE(), Assembly::buildVectorFaceNeighborFE(), Assembly::buildVectorFE(), Assembly::buildVectorLowerDFE(), Assembly::buildVectorNeighborFE(), ColumnMajorMatrixTempl< Real >::ColumnMajorMatrixTempl(), Assembly::computeADFace(), LinearFVAnisotropicDiffusion::computeBoundaryMatrixContribution(), LinearFVAnisotropicDiffusion::computeBoundaryRHSContribution(), Assembly::computeFaceMap(), LinearFVAnisotropicDiffusion::computeFluxMatrixContribution(), LinearFVAnisotropicDiffusion::computeFluxRHSContribution(), Assembly::computeGradPhiAD(), GenericFunctionVectorMaterialTempl< is_ad >::computeQpFunctions(), ElementW1pError::computeQpIntegral(), GenericConstantVectorMaterialTempl< is_ad >::computeQpProperties(), FVAnisotropicDiffusion::computeQpResidual(), Assembly::computeSinglePointMapAD(), ArrayParsedAux::computeValue(), ParsedAux::computeValue(), ParsedVectorAux::computeValue(), ElementH1ErrorFunctionAux::computeValue(), MooseVariableData< OutputType >::computeValuesInternal(), StackGenerator::computeWidth(), BatchMeshGeneratorAction::convertStringToCompoundRealScalar(), Assembly::createQRules(), dataLoad(), dataStore(), MooseMesh::detectOrthogonalDimRanges(), MooseMesh::detectPairedSidesets(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::diffusivityGradientProduct(), InitialConditionTempl< T >::dotHelper(), MooseMesh::effectiveSpatialDimension(), MooseVariableFE< Real >::evaluate(), IntersectionPointsAlongLine::execute(), FaceInfo::FaceInfo(), ColumnMajorMatrixTempl< Real >::fill(), MooseMesh::findAdaptivityQpMaps(), findContactPoint(), ExtraNodesetGenerator::generate(), StackGenerator::generate(), GenericFunctionVectorMaterialTempl< is_ad >::GenericFunctionVectorMaterialTempl(), MooseMesh::getBlocksMaxDimension(), Coupleable::getDefaultVectorValue(), Assembly::getFE(), Assembly::getFEFace(), Assembly::getFEFaceNeighbor(), Assembly::getFENeighbor(), MultiAppTransfer::getFromBoundingBoxes(), PenetrationThread::getInfoForFacesWithCommonNodes(), MultiAppGeneralFieldTransfer::getMaxToProblemsBBoxDimensions(), Assembly::getVectorFE(), Assembly::getVectorFEFace(), Assembly::getVectorFEFaceNeighbor(), Assembly::getVectorFENeighbor(), ArrayFunctionIC::gradient(), Moose::FV::greenGaussGradient(), Moose::FV::harmonicInterpolation(), MooseAppCoordTransform::hasScalingOrRotationTransformation(), Assembly::havePRefinement(), Assembly::helpersRequestData(), ParsedDownSelectionPositions::initialize(), PropertyReadFile::initVoronoiCenterPoints(), PenetrationThread::isFaceReasonableCandidate(), MultiAppCoordTransform::isIdentity(), MooseUtils::isZero(), PointListAdaptor< Point >::kdtree_distance(), ValueCache< T >::kdtree_get_pt(), PointListAdaptor< Point >::kdtree_get_pt(), NanoflannMeshAdaptor< Dim >::kdtree_get_pt(), NanoflannMeshSubdomainAdaptor< Dim >::kdtree_get_pt(), NodalPatchRecovery::multiIndex(), MathUtils::multiIndex(), ResetDisplacedMeshThread::onNode(), SecondaryNeighborhoodThread::operator()(), ColumnMajorMatrixTempl< Real >::operator*(), ColumnMajorMatrixTempl< Real >::operator+=(), ColumnMajorMatrixTempl< Real >::operator=(), MaterialOutputAction::outputHelper(), GriddedData::parse(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), PenetrationLocator::PenetrationLocator(), PropertyReadFile::PropertyReadFile(), Assembly::qruleFaceHelper(), Assembly::qrules(), Assembly::reinitFE(), Assembly::reinitFEFace(), Assembly::reinitFVFace(), Assembly::reinitNeighbor(), MooseUtils::relativeFuzzyEqual(), Assembly::resizeADMappingObjects(), PiecewiseMultilinear::sampleInternal(), Assembly::setFaceQRule(), Assembly::setLowerQRule(), Assembly::setMortarQRule(), Assembly::setNeighborQRule(), SideSetsGeneratorBase::setup(), Assembly::setVolumeQRule(), sideIntersectedByLine(), MultiIndex< Real >::slice(), MultiApp::transformBoundingBox(), MortarData::update(), BoundingBoxIC::value(), MeshBaseImageSampler::vtkFlip(), Assembly::~Assembly(), and PenetrationLocator::~PenetrationLocator().

eigen_problem_type_to_enum

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

Definition at line 29 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 28 of file Conversion.C.

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

EMPTY_BLOCK_IDS

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

Definition at line 683 of file MooseTypes.h.

EMPTY_BOUNDARY_IDS

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

Definition at line 684 of file MooseTypes.h.

execute_flags

ExecFlagEnum Moose::execute_flags

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.

Referenced by InputParameters::declareControllable(), and groupUserObjects().

interrupt_signal_number

int 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 760 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(), ComputeResidualThread::computeOnInternalFace(), ComputeFullJacobianThread::computeOnInternalFace(), MultiAppGeometricInterpolationTransfer::computeTransformation(), SubdomainsDivision::divisionIndex(), ElementSubdomainModifier::execute(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), ElementSubdomainModifierBase::gatherMovingBoundaryChangesHelper(), RenameBlockGenerator::generate(), BlockToMeshConverterGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), MooseMeshUtils::getSubdomainID(), TimedSubdomainModifier::getSubdomainIDAndCheck(), MooseMeshUtils::hasSubdomainID(), ElementSubdomainModifierBase::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), AttribSubdomains::isMatch(), FaceInfo::neighborSubdomainID(), ComputeJacobianForScalingThread::operator()(), ThreadedElementLoopBase< ConstElemPointerRange >::operator()(), ComputeLinearFVElementalThread::operator()(), ComputeLinearFVFaceThread::operator()(), ThreadedFaceLoop< RangeType >::operator()(), ComputeLinearFVFaceThread::printBlockExecutionInformation(), ComputeFVFluxThread< RangeType, AttribMatrixTags >::printBlockExecutionInformation(), ComputeFVFluxThread< RangeType, AttribMatrixTags >::printBoundaryExecutionInformation(), MooseMeshXYCuttingUtils::quadToTriOnLine(), MooseMeshXYCuttingUtils::quasiTriElementsFixer(), and PiecewiseByBlockLambdaFunctor< T >::setFunctor().

INVALID_BOUNDARY_ID

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

Definition at line 22 of file MooseTypes.C.

Referenced by BreakMeshByBlockGenerator::addInterfaceBoundary(), MultiAppNearestNodeTransfer::execute(), SidesetAroundSubdomainUpdater::executeOnExternalSide(), RenameBoundaryGenerator::generate(), RefineSidesetGenerator::generate(), BreakMeshByBlockGenerator::generate(), SideSetsFromBoundingBoxGenerator::generate(), BreakMeshByElementGenerator::generate(), PatternedMeshGenerator::generate(), MooseMeshUtils::getBoundaryID(), MooseMeshUtils::hasBoundaryID(), NonlinearThread::onInternalSide(), GhostBoundary::operator()(), MooseMesh::prepare(), NonlinearThread::prepareFace(), SidesetAroundSubdomainUpdater::processSide(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), 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_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().

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 31 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 33 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

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_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(), SystemBase::oldSolutionStateVectorName(), NonlinearSystemBase::setPreviousNewtonSolution(), SystemBase::solutionPreviousNewton(), and MooseVariableDataBase< OutputType >::stateToTagHelper().

rm_type_to_enum

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

Definition at line 34 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 762 of file Moose.C.

show_trace

bool Moose::show_trace = true

Set to true (the default) to print the stack trace with error and warning messages - false to omit it.

Definition at line 761 of file Moose.C.

Referenced by InputParameters::attemptPrintDeprecated(), Factory::deprecatedMessage(), MooseApp::MooseApp(), moose::internal::mooseDeprecatedStream(), moose::internal::mooseErrorRaw(), and MooseBaseParameterInterface::paramError().

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 27 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 32 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 30 of file Conversion.C.

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