SubProblem Class Reference

Generic class for solving transient nonlinear problems. More...

#include <SubProblem.h>

Inheritance diagram for SubProblem:

Public Types
using	DataFileParameterType = DataFileName
	The parameter type this interface expects for a data file name.

Public Member Functions
	SubProblem (const InputParameters &parameters)
virtual	~SubProblem ()
virtual libMesh::EquationSystems &	es ()=0
virtual MooseMesh &	mesh ()=0
virtual const MooseMesh &	mesh () const =0
virtual const MooseMesh &	mesh (bool use_displaced) const =0
THREAD_ID	numThreads () const
virtual bool	checkNonlocalCouplingRequirement () const =0
virtual bool	solverSystemConverged (const unsigned int sys_num)
virtual bool	nlConverged (const unsigned int nl_sys_num)
virtual bool	converged (const unsigned int sys_num)
	Eventually we want to convert this virtual over to taking a solver system number argument.
virtual unsigned int	nlSysNum (const NonlinearSystemName &nl_sys_name) const =0
virtual unsigned int	linearSysNum (const LinearSystemName &linear_sys_name) const =0
virtual unsigned int	solverSysNum (const SolverSystemName &solver_sys_name) const =0
virtual void	onTimestepBegin ()=0
virtual void	onTimestepEnd ()=0
virtual bool	isTransient () const =0
virtual void	needFV ()=0
	marks this problem as including/needing finite volume functionality.
virtual bool	haveFV () const =0
	returns true if this problem includes/needs finite volume functionality.
bool	defaultGhosting ()
	Whether or not the user has requested default ghosting ot be on.
virtual TagID	addVectorTag (const TagName &tag_name, const Moose::VectorTagType type=Moose::VECTOR_TAG_RESIDUAL)
	Create a Tag.
void	addNotZeroedVectorTag (const TagID tag)
	Adds a vector tag to the list of vectors that will not be zeroed when other tagged vectors are.
bool	vectorTagNotZeroed (const TagID tag) const
	Checks if a vector tag is in the list of vectors that will not be zeroed when other tagged vectors are.
virtual const VectorTag &	getVectorTag (const TagID tag_id) const
	Get a VectorTag from a TagID.
std::vector< VectorTag >	getVectorTags (const std::set< TagID > &tag_ids) const
virtual TagID	getVectorTagID (const TagName &tag_name) const
	Get a TagID from a TagName.
virtual TagName	vectorTagName (const TagID tag) const
	Retrieve the name associated with a TagID.
virtual const std::vector< VectorTag > &	getVectorTags (const Moose::VectorTagType type=Moose::VECTOR_TAG_ANY) const
	Return all vector tags, where a tag is represented by a map from name to ID.
virtual bool	vectorTagExists (const TagID tag_id) const
	Check to see if a particular Tag exists.
virtual bool	vectorTagExists (const TagName &tag_name) const
	Check to see if a particular Tag exists by using Tag name.
virtual unsigned int	numVectorTags (const Moose::VectorTagType type=Moose::VECTOR_TAG_ANY) const
	The total number of tags, which can be limited to the tag type.
virtual Moose::VectorTagType	vectorTagType (const TagID tag_id) const
virtual TagID	addMatrixTag (TagName tag_name)
	Create a Tag.
virtual TagID	getMatrixTagID (const TagName &tag_name) const
	Get a TagID from a TagName.
virtual TagName	matrixTagName (TagID tag)
	Retrieve the name associated with a TagID.
virtual bool	matrixTagExists (const TagName &tag_name) const
	Check to see if a particular Tag exists.
virtual bool	matrixTagExists (TagID tag_id) const
	Check to see if a particular Tag exists.
virtual unsigned int	numMatrixTags () const
	The total number of tags.
virtual std::map< TagName, TagID > &	getMatrixTags ()
	Return all matrix tags in the system, where a tag is represented by a map from name to ID.
virtual bool	hasVariable (const std::string &var_name) const =0
	Whether or not this problem has the variable.
virtual bool	hasLinearVariable (const std::string &var_name) const
	Whether or not this problem has this linear variable.
virtual bool	hasAuxiliaryVariable (const std::string &var_name) const
	Whether or not this problem has this auxiliary variable.
virtual const MooseVariableFieldBase &	getVariable (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const =0
	Returns the variable reference for requested variable which must be of the expected_var_type (Nonlinear vs.
virtual MooseVariableFieldBase &	getVariable (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY)
virtual MooseVariable &	getStandardVariable (const THREAD_ID tid, const std::string &var_name)=0
	Returns the variable reference for requested MooseVariable which may be in any system.
virtual MooseVariableFieldBase &	getActualFieldVariable (const THREAD_ID tid, const std::string &var_name)=0
	Returns the variable reference for requested MooseVariableField which may be in any system.
virtual VectorMooseVariable &	getVectorVariable (const THREAD_ID tid, const std::string &var_name)=0
	Returns the variable reference for requested VectorMooseVariable which may be in any system.
virtual ArrayMooseVariable &	getArrayVariable (const THREAD_ID tid, const std::string &var_name)=0
	Returns the variable reference for requested ArrayMooseVariable which may be in any system.
virtual bool	hasScalarVariable (const std::string &var_name) const =0
	Returns a Boolean indicating whether any system contains a variable with the name provided.
virtual MooseVariableScalar &	getScalarVariable (const THREAD_ID tid, const std::string &var_name)=0
	Returns the scalar variable reference from whichever system contains it.
virtual libMesh::System &	getSystem (const std::string &var_name)=0
	Returns the equation system containing the variable provided.
virtual void	setActiveElementalMooseVariables (const std::set< MooseVariableFieldBase * > &moose_vars, const THREAD_ID tid)
	Set the MOOSE variables to be reinited on each element.
virtual const std::set< MooseVariableFieldBase * > &	getActiveElementalMooseVariables (const THREAD_ID tid) const
	Get the MOOSE variables to be reinited on each element.
virtual bool	hasActiveElementalMooseVariables (const THREAD_ID tid) const
	Whether or not a list of active elemental moose variables has been set.
virtual void	clearActiveElementalMooseVariables (const THREAD_ID tid)
	Clear the active elemental MooseVariableFieldBase.
virtual Assembly &	assembly (const THREAD_ID tid, const unsigned int sys_num)=0
virtual const Assembly &	assembly (const THREAD_ID tid, const unsigned int sys_num) const =0
virtual const SystemBase &	systemBaseNonlinear (const unsigned int sys_num) const =0
	Return the nonlinear system object as a base class reference given the system number.
virtual SystemBase &	systemBaseNonlinear (const unsigned int sys_num)=0
virtual const SystemBase &	systemBaseLinear (const unsigned int sys_num) const =0
	Return the linear system object as a base class reference given the system number.
virtual SystemBase &	systemBaseLinear (const unsigned int sys_num)=0
virtual const SystemBase &	systemBaseSolver (const unsigned int sys_num) const =0
	Return the solver system object as a base class reference given the system number.
virtual SystemBase &	systemBaseSolver (const unsigned int sys_num)=0
virtual const SystemBase &	systemBaseAuxiliary () const =0
	Return the auxiliary system object as a base class reference.
virtual SystemBase &	systemBaseAuxiliary ()=0
virtual void	prepareShapes (unsigned int var, const THREAD_ID tid)=0
virtual void	prepareFaceShapes (unsigned int var, const THREAD_ID tid)=0
virtual void	prepareNeighborShapes (unsigned int var, const THREAD_ID tid)=0
Moose::CoordinateSystemType	getCoordSystem (SubdomainID sid) const
unsigned int	getAxisymmetricRadialCoord () const
	Returns the desired radial direction for RZ coordinate transformation.
virtual DiracKernelInfo &	diracKernelInfo ()
virtual Real	finalNonlinearResidual (const unsigned int nl_sys_num) const
virtual unsigned int	nNonlinearIterations (const unsigned int nl_sys_num) const
virtual unsigned int	nLinearIterations (const unsigned int nl_sys_num) const
virtual void	addResidual (const THREAD_ID tid)=0
virtual void	addResidualNeighbor (const THREAD_ID tid)=0
virtual void	addResidualLower (const THREAD_ID tid)=0
virtual void	cacheResidual (const THREAD_ID tid)
virtual void	cacheResidualNeighbor (const THREAD_ID tid)
virtual void	addCachedResidual (const THREAD_ID tid)
virtual void	setResidual (libMesh::NumericVector< libMesh::Number > &residual, const THREAD_ID tid)=0
virtual void	setResidualNeighbor (libMesh::NumericVector< libMesh::Number > &residual, const THREAD_ID tid)=0
virtual void	addJacobian (const THREAD_ID tid)=0
virtual void	addJacobianNeighbor (const THREAD_ID tid)=0
virtual void	addJacobianNeighborLowerD (const THREAD_ID tid)=0
virtual void	addJacobianLowerD (const THREAD_ID tid)=0
virtual void	addJacobianNeighbor (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const libMesh::DofMap &dof_map, std::vector< dof_id_type > &dof_indices, std::vector< dof_id_type > &neighbor_dof_indices, const std::set< TagID > &tags, const THREAD_ID tid)=0
virtual void	cacheJacobian (const THREAD_ID tid)
virtual void	cacheJacobianNeighbor (const THREAD_ID tid)
virtual void	addCachedJacobian (const THREAD_ID tid)
virtual void	prepare (const Elem *elem, const THREAD_ID tid)=0
virtual void	prepareFace (const Elem *elem, const THREAD_ID tid)=0
virtual void	prepare (const Elem *elem, unsigned int ivar, unsigned int jvar, const std::vector< dof_id_type > &dof_indices, const THREAD_ID tid)=0
virtual void	setCurrentSubdomainID (const Elem *elem, const THREAD_ID tid)=0
virtual void	setNeighborSubdomainID (const Elem *elem, unsigned int side, const THREAD_ID tid)=0
virtual void	prepareAssembly (const THREAD_ID tid)=0
virtual void	reinitElem (const Elem *elem, const THREAD_ID tid)=0
virtual void	reinitElemPhys (const Elem *elem, const std::vector< Point > &phys_points_in_elem, const THREAD_ID tid)=0
virtual void	reinitElemFace (const Elem *elem, unsigned int side, const THREAD_ID tid)=0
virtual void	reinitLowerDElem (const Elem *lower_d_elem, const THREAD_ID tid, const std::vector< Point > *const pts=nullptr, const std::vector< Real > *const weights=nullptr)
virtual void	reinitNode (const Node *node, const THREAD_ID tid)=0
virtual void	reinitNodeFace (const Node *node, BoundaryID bnd_id, const THREAD_ID tid)=0
void	reinitNodes (const std::vector< dof_id_type > &nodes, const THREAD_ID tid)
void	reinitNodesNeighbor (const std::vector< dof_id_type > &nodes, const THREAD_ID tid)
virtual void	reinitNeighbor (const Elem *elem, unsigned int side, const THREAD_ID tid)=0
virtual void	reinitNeighborPhys (const Elem *neighbor, unsigned int neighbor_side, const std::vector< Point > &physical_points, const THREAD_ID tid)=0
virtual void	reinitNeighborPhys (const Elem *neighbor, const std::vector< Point > &physical_points, const THREAD_ID tid)=0
virtual void	reinitElemNeighborAndLowerD (const Elem *elem, unsigned int side, const THREAD_ID tid)=0
virtual void	reinitScalars (const THREAD_ID tid, bool reinit_for_derivative_reordering=false)=0
	fills the VariableValue arrays for scalar variables from the solution vector
virtual void	reinitOffDiagScalars (const THREAD_ID tid)=0
virtual void	setCurrentBoundaryID (BoundaryID bid, const THREAD_ID tid)
	sets the current boundary ID in assembly
virtual void	reinitElemFaceRef (const Elem *elem, unsigned int side, Real tolerance, const std::vector< Point > *const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0)
	reinitialize FE objects on a given element on a given side at a given set of reference points and then compute variable data.
virtual void	reinitNeighborFaceRef (const Elem *neighbor_elem, unsigned int neighbor_side, Real tolerance, const std::vector< Point > *const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0)
	reinitialize FE objects on a given neighbor element on a given side at a given set of reference points and then compute variable data.
void	reinitNeighborLowerDElem (const Elem *elem, const THREAD_ID tid=0)
	reinitialize a neighboring lower dimensional element
void	reinitMortarElem (const Elem *elem, const THREAD_ID tid=0)
	Reinit a mortar element to obtain a valid JxW.
virtual bool	reinitDirac (const Elem *elem, const THREAD_ID tid)=0
	Returns true if the Problem has Dirac kernels it needs to compute on elem.
virtual void	getDiracElements (std::set< const Elem * > &elems)=0
	Fills "elems" with the elements that should be looped over for Dirac Kernels.
virtual void	clearDiracInfo ()=0
	Gets called before Dirac Kernels are asked to add the points they are supposed to be evaluated in.
virtual void	updateGeomSearch (GeometricSearchData::GeometricSearchType type=GeometricSearchData::ALL)=0
	update geometric search data
void	reinitGeomSearch ()
	reinitialize this object's geometric search data, e.g.
virtual GeometricSearchData &	geomSearchData ()=0
virtual void	storeSubdomainMatPropName (SubdomainID block_id, const std::string &name)
	Adds the given material property to a storage map based on block ids.
virtual void	storeBoundaryMatPropName (BoundaryID boundary_id, const std::string &name)
	Adds the given material property to a storage map based on boundary ids.
virtual void	storeSubdomainZeroMatProp (SubdomainID block_id, const MaterialPropertyName &name)
	Adds to a map based on block ids of material properties for which a zero value can be returned.
virtual void	storeBoundaryZeroMatProp (BoundaryID boundary_id, const MaterialPropertyName &name)
	Adds to a map based on boundary ids of material properties for which a zero value can be returned.
virtual void	storeSubdomainDelayedCheckMatProp (const std::string &requestor, SubdomainID block_id, const std::string &name)
	Adds to a map based on block ids of material properties to validate.
virtual void	storeBoundaryDelayedCheckMatProp (const std::string &requestor, BoundaryID boundary_id, const std::string &name)
	Adds to a map based on boundary ids of material properties to validate.
virtual void	checkBlockMatProps ()
	Checks block material properties integrity.
virtual void	checkBoundaryMatProps ()
	Checks boundary material properties integrity.
virtual void	markMatPropRequested (const std::string &)
	Helper method for adding a material property name to the _material_property_requested set.
virtual bool	isMatPropRequested (const std::string &prop_name) const
	Find out if a material property has been requested by any object.
void	addConsumedPropertyName (const MooseObjectName &obj_name, const std::string &prop_name)
	Helper for tracking the object that is consuming a property for MaterialPropertyDebugOutput.
const std::map< MooseObjectName, std::set< std::string > > &	getConsumedPropertyMap () const
	Return the map that tracks the object with consumed material properties.
virtual void	addGhostedElem (dof_id_type elem_id)=0
	Will make sure that all dofs connected to elem_id are ghosted to this processor.
virtual void	addGhostedBoundary (BoundaryID boundary_id)=0
	Will make sure that all necessary elements from boundary_id are ghosted to this processor.
virtual void	ghostGhostedBoundaries ()=0
	Causes the boundaries added using addGhostedBoundary to actually be ghosted.
virtual std::set< SubdomainID >	getMaterialPropertyBlocks (const std::string &prop_name)
	Get a vector containing the block ids the material property is defined on.
virtual std::vector< SubdomainName >	getMaterialPropertyBlockNames (const std::string &prop_name)
	Get a vector of block id equivalences that the material property is defined on.
virtual bool	hasBlockMaterialProperty (SubdomainID block_id, const std::string &prop_name)
	Check if a material property is defined on a block.
virtual std::set< BoundaryID >	getMaterialPropertyBoundaryIDs (const std::string &prop_name)
	Get a vector containing the block ids the material property is defined on.
virtual std::vector< BoundaryName >	getMaterialPropertyBoundaryNames (const std::string &prop_name)
	Get a vector of block id equivalences that the material property is defined on.
virtual bool	hasBoundaryMaterialProperty (BoundaryID boundary_id, const std::string &prop_name)
	Check if a material property is defined on a block.
virtual bool	computingPreSMOResidual (const unsigned int nl_sys_num) const =0
	Returns true if the problem is in the process of computing it's initial residual.
virtual std::set< dof_id_type > &	ghostedElems ()
	Return the list of elements that should have their DoFs ghosted to this processor.
virtual const libMesh::CouplingMatrix &	nonlocalCouplingMatrix (const unsigned i) const =0
const bool &	currentlyComputingJacobian () const
	Returns true if the problem is in the process of computing the Jacobian.
void	setCurrentlyComputingJacobian (const bool currently_computing_jacobian)
	Set whether or not the problem is in the process of computing the Jacobian.
const bool &	currentlyComputingResidualAndJacobian () const
	Returns true if the problem is in the process of computing the residual and the Jacobian.
void	setCurrentlyComputingResidualAndJacobian (bool currently_computing_residual_and_jacobian)
	Set whether or not the problem is in the process of computing the Jacobian.
bool	computingNonlinearResid () const
	Returns true if the problem is in the process of computing the nonlinear residual.
virtual void	computingNonlinearResid (const bool computing_nonlinear_residual)
	Set whether or not the problem is in the process of computing the nonlinear residual.
const bool &	currentlyComputingResidual () const
	Returns true if the problem is in the process of computing the residual.
virtual void	setCurrentlyComputingResidual (const bool currently_computing_residual)
	Set whether or not the problem is in the process of computing the residual.
virtual bool	safeAccessTaggedMatrices () const
	Is it safe to access the tagged matrices.
virtual bool	safeAccessTaggedVectors () const
	Is it safe to access the tagged vectors.
virtual void	clearActiveFEVariableCoupleableMatrixTags (const THREAD_ID tid)
virtual void	clearActiveFEVariableCoupleableVectorTags (const THREAD_ID tid)
virtual void	setActiveFEVariableCoupleableVectorTags (std::set< TagID > &vtags, const THREAD_ID tid)
virtual void	setActiveFEVariableCoupleableMatrixTags (std::set< TagID > &mtags, const THREAD_ID tid)
virtual void	clearActiveScalarVariableCoupleableMatrixTags (const THREAD_ID tid)
virtual void	clearActiveScalarVariableCoupleableVectorTags (const THREAD_ID tid)
virtual void	setActiveScalarVariableCoupleableVectorTags (std::set< TagID > &vtags, const THREAD_ID tid)
virtual void	setActiveScalarVariableCoupleableMatrixTags (std::set< TagID > &mtags, const THREAD_ID tid)
const std::set< TagID > &	getActiveScalarVariableCoupleableVectorTags (const THREAD_ID tid) const
const std::set< TagID > &	getActiveScalarVariableCoupleableMatrixTags (const THREAD_ID tid) const
const std::set< TagID > &	getActiveFEVariableCoupleableVectorTags (const THREAD_ID tid) const
const std::set< TagID > &	getActiveFEVariableCoupleableMatrixTags (const THREAD_ID tid) const
virtual void	haveADObjects (bool have_ad_objects)
	Method for setting whether we have any ad objects.
bool	haveADObjects () const
	Method for reading wehther we have any ad objects.
virtual LineSearch *	getLineSearch ()=0
virtual const libMesh::CouplingMatrix *	couplingMatrix (const unsigned int nl_sys_num) const =0
	The coupling matrix defining what blocks exist in the preconditioning matrix.
void	addAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf, bool to_mesh=true)
	Add an algebraic ghosting functor to this problem's DofMaps.
void	addCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf, bool to_mesh=true)
	Add a coupling functor to this problem's DofMaps.
void	removeAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf)
	Remove an algebraic ghosting functor from this problem's DofMaps.
void	removeCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf)
	Remove a coupling ghosting functor from this problem's DofMaps.
virtual void	automaticScaling (bool automatic_scaling)
	Automatic scaling setter.
bool	automaticScaling () const
	Automatic scaling getter.
virtual bool	haveDisplaced () const =0
	Whether we have a displaced problem in our simulation.
virtual bool	computingScalingJacobian () const =0
	Getter for whether we're computing the scaling jacobian.
virtual bool	computingScalingResidual () const =0
	Getter for whether we're computing the scaling residual.
void	clearAllDofIndices ()
	Clear dof indices from variables in nl and aux systems.
template<typename T >
const Moose::Functor< T > &	getFunctor (const std::string &name, const THREAD_ID tid, const std::string &requestor_name, bool requestor_is_ad)
bool	hasFunctor (const std::string &name, const THREAD_ID tid) const
	checks whether we have a functor corresponding to name on the thread id tid
template<typename T >
bool	hasFunctorWithType (const std::string &name, const THREAD_ID tid) const
	checks whether we have a functor of type T corresponding to name on the thread id tid
template<typename T >
void	addFunctor (const std::string &name, const Moose::FunctorBase< T > &functor, const THREAD_ID tid)
	add a functor to the problem functor container
template<typename T , typename PolymorphicLambda >
const Moose::FunctorBase< T > &	addPiecewiseByBlockLambdaFunctor (const std::string &name, PolymorphicLambda my_lammy, const std::set< ExecFlagType > &clearance_schedule, const MooseMesh &mesh, const std::set< SubdomainID > &block_ids, const THREAD_ID tid)
	Add a functor that has block-wise lambda definitions, e.g.
virtual void	initialSetup ()
virtual void	timestepSetup ()
virtual void	customSetup (const ExecFlagType &exec_type)
virtual void	residualSetup ()
virtual void	jacobianSetup ()
void	setFunctorOutput (bool set_output)
	Setter for debug functor output.
void	setChainControlDataOutput (bool set_output)
	Setter for debug chain control data output.
virtual bool	checkResidualForNans () const =0
	Whether to check residual for NaN/Inf values.
virtual std::size_t	numNonlinearSystems () const =0
virtual unsigned int	currentNlSysNum () const =0
virtual std::size_t	numLinearSystems () const =0
virtual std::size_t	numSolverSystems () const =0
virtual unsigned int	currentLinearSysNum () const =0
template<typename T >
void	registerUnfilledFunctorRequest (T *functor_interface, const std::string &functor_name, const THREAD_ID tid)
	Register an unfulfilled functor request.
virtual const std::vector< VectorTag > &	currentResidualVectorTags () const =0
	Return the residual vector tags we are currently computing.
void	reinitFVFace (const THREAD_ID tid, const FaceInfo &fi)
	reinitialize the finite volume assembly data for the provided face and thread
virtual bool	hasNonlocalCoupling () const =0
	Whether the simulation has active nonlocal coupling which should be accounted for in the Jacobian.
void	preparePRefinement ()
	Prepare DofMap and Assembly classes with our p-refinement information.
bool	doingPRefinement () const
virtual void	setCurrentLowerDElem (const Elem *const lower_d_elem, const THREAD_ID tid)
	Set the current lower dimensional element.
template<typename T >
MooseVariableFEBase &	getVariableHelper (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type, Moose::VarFieldType expected_var_field_type, const std::vector< T > &systems, const SystemBase &aux) const
virtual void	init ()=0
void	_setCLIOption ()
	For Internal Use.
virtual void	terminateSolve ()
	Allow objects to request clean termination of the solve.
virtual bool	isSolveTerminationRequested () const
	Check of termination has been requested.
const ConsoleStream &	console () const
	Return console handle.
virtual bool	enabled () const
	Return the enabled status of the object.
std::shared_ptr< MooseObject >	getSharedPtr ()
	Get another shared pointer to this object that has the same ownership group.
std::shared_ptr< const MooseObject >	getSharedPtr () const
bool	isKokkosObject () const
	Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.
MooseApp &	getMooseApp () const
	Get the MooseApp this class is associated with.
const std::string &	type () const
	Get the type of this class.
const std::string &	name () const
	Get the name of the class.
std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling.
MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const
MooseObjectName	uniqueName () const
const InputParameters &	parameters () const
	Get the parameters of the object.
const hit::Node *	getHitNode () const
bool	hasBase () const
const std::string &	getBase () const
template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a parameter for the object.
template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
	Retrieve two parameters and provide pair of parameters for the object.
template<typename T >
const T *	queryParam (const std::string &name) const
	Query a parameter for the object.
template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object.
template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller.
bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid.
bool	isParamSetByUser (const std::string &name) const
	Test if the supplied parameter is set by a user, as opposed to not set or set to default.
void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
	Connect controllable parameter of this action with the controllable parameters of the objects added by this action.
template<typename... Args>
void	paramError (const std::string &param, Args... args) const
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.
template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.
template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const
template<typename... Args>
void	paramInfo (const std::string &param, Args... args) const
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.
std::string	messagePrefix (const bool hit_prefix=true) const
std::string	errorPrefix (const std::string &) const
	Deprecated message prefix; the error type is no longer used.
template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.
template<typename... Args>
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const
template<typename... Args>
void	mooseErrorNonPrefixed (Args &&... args) const
	Emits an error without the prefixing included in mooseError().
template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type.
template<typename... Args>
void	mooseWarning (Args &&... args) const
template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
	Emits a warning without the prefixing included in mooseWarning().
template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and a stack trace.
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
template<typename... Args>
void	mooseDeprecatedNoTrace (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and no stack trace.
template<typename... Args>
void	mooseInfo (Args &&... args) const
void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
	External method for calling moose error with added object context.
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
std::string	getDataFileName (const std::string &param) const
	Deprecated method.
std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method.
std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path.
PerfGraph &	perfGraph ()
	Get the PerfGraph.

Static Public Member Functions
static InputParameters	validParams ()
static void	selectVectorTagsFromSystem (const SystemBase &system, const std::vector< VectorTag > &input_vector_tags, std::set< TagID > &selected_tags)
	Select the vector tags which belong to a specific system.
static void	selectMatrixTagsFromSystem (const SystemBase &system, const std::map< TagName, TagID > &input_matrix_tags, std::set< TagID > &selected_tags)
	Select the matrix tags which belong to a specific system.
static void	callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node, const bool show_trace=true)
	External method for calling moose error with added object context.

Public Attributes
std::map< std::string, std::vector< dof_id_type > >	_var_dof_map
	usingCombinedWarningSolutionWarnings
const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects.

Static Public Attributes
static const std::string	type_param = "_type"
	The name of the parameter that contains the object type.
static const std::string	name_param = "_object_name"
	The name of the parameter that contains the object name.
static const std::string	unique_name_param = "_unique_name"
	The name of the parameter that contains the unique object name.
static const std::string	app_param = "_moose_app"
	The name of the parameter that contains the MooseApp.
static const std::string	moose_base_param = "_moose_base"
	The name of the parameter that contains the moose system base.
static const std::string	kokkos_object_param = "_kokkos_object"
	The name of the parameter that indicates an object is a Kokkos functor.

Protected Member Functions
template<typename T >
MooseVariableFieldBase &	getVariableHelper (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type, Moose::VarFieldType expected_var_field_type, const std::vector< T > &nls, const SystemBase &aux) const
	Helper function called by getVariable that handles the logic for checking whether Variables of the requested type are available.
bool	verifyVectorTags () const
	Verify the integrity of _vector_tags and _typed_vector_tags.
template<bool warning>
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
	Set solution invalid mark for the given solution ID.
InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing.
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing.
std::string	timedSectionName (const std::string &section_name) const

Protected Attributes
std::map< TagName, TagID >	_matrix_tag_name_to_tag_id
	The currently declared tags.
std::map< TagID, TagName >	_matrix_tag_id_to_tag_name
	Reverse map.
Factory &	_factory
	The Factory for building objects.
DiracKernelInfo	_dirac_kernel_info
std::map< SubdomainID, std::set< std::string > >	_map_block_material_props
	Map of material properties (block_id -> list of properties)
std::map< BoundaryID, std::set< std::string > >	_map_boundary_material_props
	Map for boundary material properties (boundary_id -> list of properties)
std::map< SubdomainID, std::set< MaterialPropertyName > >	_zero_block_material_props
	Set of properties returned as zero properties.
std::map< BoundaryID, std::set< MaterialPropertyName > >	_zero_boundary_material_props
std::set< std::string >	_material_property_requested
	set containing all material property names that have been requested by getMaterialProperty*
std::vector< std::set< MooseVariableFieldBase * > >	_active_elemental_moose_variables
	This is the set of MooseVariableFieldBase that will actually get reinited by a call to reinit(elem)
std::vector< unsigned int >	_has_active_elemental_moose_variables
	Whether or not there is currently a list of active elemental moose variables.
std::vector< std::set< TagID > >	_active_fe_var_coupleable_matrix_tags
std::vector< std::set< TagID > >	_active_fe_var_coupleable_vector_tags
std::vector< std::set< TagID > >	_active_sc_var_coupleable_matrix_tags
std::vector< std::set< TagID > >	_active_sc_var_coupleable_vector_tags
bool	_default_ghosting
	Whether or not to use default libMesh coupling.
std::set< dof_id_type >	_ghosted_elems
	Elements that should have Dofs ghosted to the local processor.
bool	_currently_computing_jacobian
	Flag to determine whether the problem is currently computing Jacobian.
bool	_currently_computing_residual_and_jacobian
	Flag to determine whether the problem is currently computing the residual and Jacobian.
bool	_computing_nonlinear_residual
	Whether the non-linear residual is being evaluated.
bool	_currently_computing_residual
	Whether the residual is being evaluated.
bool	_safe_access_tagged_matrices
	Is it safe to retrieve data from tagged matrices.
bool	_safe_access_tagged_vectors
	Is it safe to retrieve data from tagged vectors.
bool	_have_ad_objects
	AD flag indicating whether any AD objects have been added.
std::unordered_set< TagID >	_not_zeroed_tagged_vectors
	the list of vector tags that will not be zeroed when all other tags are
bool	_cli_option_found
	True if the CLI option is found.
bool	_color_output
	True if we're going to attempt to write color output.
bool	_termination_requested
	True if termination of the solve has been requested.
const bool &	_enabled
	Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.
MooseApp &	_app
	The MOOSE application this is associated with.
ActionFactory &	_action_factory
	Builds Actions.
const std::string &	_type
	The type of this class.
const std::string &	_name
	The name of this class.
const InputParameters &	_pars
	The object's parameters.
const Parallel::Communicator &	_communicator
MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph.
const std::string	_prefix
	A prefix to use for all sections.
std::map< SubdomainID, std::multimap< std::string, std::string > >	_map_block_material_props_check
	Data structures of the requested material properties.
std::map< BoundaryID, std::multimap< std::string, std::string > >	_map_boundary_material_props_check

Private Types
enum class	TrueFunctorIs { UNSET , NONAD , AD }

Private Member Functions
void	cloneAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf, bool to_mesh=true)
	Creates (n_sys - 1) clones of the provided algebraic ghosting functor (corresponding to the nonlinear system algebraic ghosting functor), initializes the clone with the appropriate DofMap, and then adds the clone to said DofMap.
void	cloneCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf, bool to_mesh=true)
	Creates (n_sys - 1) clones of the provided coupling ghosting functor (corresponding to the nonlinear system coupling ghosting functor), initializes the clone with the appropriate DofMap, and then adds the clone to said DofMap.
virtual std::pair< bool, unsigned int >	determineSolverSystem (const std::string &var_name, bool error_if_not_found=false) const =0
void	showFunctors () const
	Lists all functors in the problem.
void	showFunctorRequestors () const
	Lists all functors and all the objects that requested them.
std::string	restrictionSubdomainCheckName (SubdomainID check_id)
	Helper functions for checking MaterialProperties.
std::string	restrictionBoundaryCheckName (BoundaryID check_id)

Static Private Member Functions
static const hit::Node *	getHitNode (const InputParameters &params)
	Internal method for getting a hit node (if available) given a set of parameters.
static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)
	Internal method for getting the message prefix for an object (object type, name, etc).

Private Attributes
std::vector< std::multimap< std::string, std::tuple< TrueFunctorIs, std::unique_ptr< Moose::FunctorEnvelopeBase >, std::unique_ptr< Moose::FunctorEnvelopeBase > > > >	_functors
	A container holding pointers to all the functors in our problem.
std::vector< std::map< std::string, std::unique_ptr< Moose::FunctorAbstract > > >	_pbblf_functors
	Container to hold PiecewiseByBlockLambdaFunctors.
std::map< std::string, std::set< std::string > >	_functor_to_requestors
	The requestors of functors where the key is the prop name and the value is a set of names of requestors.
std::vector< std::multimap< std::string, std::pair< bool, bool > > >	_functor_to_request_info
	A multimap (for each thread) from unfilled functor requests to whether the requests were for AD functors and whether the requestor was an AD object.
bool	_show_functors
	Whether to output a list of the functors used and requested (currently only at initialSetup)
bool	_show_chain_control_data
	Whether to output a list of all the chain control data.
std::vector< VectorTag >	_vector_tags
	The declared vector tags.
std::vector< std::vector< VectorTag > >	_typed_vector_tags
	The vector tags associated with each VectorTagType This is kept separate from _vector_tags for quick access into typed vector tags in places where we don't want to build a new vector every call (like in residual evaluation)
std::map< TagName, TagID >	_vector_tags_name_map
	Map of vector tag TagName to TagID.
std::map< MooseObjectName, std::set< std::string > >	_consumed_material_properties
std::unordered_map< libMesh::GhostingFunctor *, std::vector< std::shared_ptr< libMesh::GhostingFunctor > > >	_root_alg_gf_to_sys_clones
	A map from a root algebraic ghosting functor, e.g.
std::unordered_map< libMesh::GhostingFunctor *, std::vector< std::shared_ptr< libMesh::GhostingFunctor > > >	_root_coupling_gf_to_sys_clones
	A map from a root coupling ghosting functor, e.g.
const ParallelParamObject &	_parent
const MooseBase &	_si_moose_base
	The MooseBase that owns this interface.
const FEProblemBase *	_si_problem
	A pointer to FEProblem base.

Friends
class	Restartable

Detailed Description

Generic class for solving transient nonlinear problems.

Definition at line 78 of file SubProblem.h.

Member Typedef Documentation

DataFileParameterType

using DataFileInterface::DataFileParameterType = DataFileName

inherited

The parameter type this interface expects for a data file name.

Definition at line 27 of file DataFileInterface.h.

Member Enumeration Documentation

TrueFunctorIs

enum class SubProblem::TrueFunctorIs

strongprivate

Enumerator
UNSET
NONAD
AD

Definition at line 1130 of file SubProblem.h.

  {
    UNSET,
    NONAD,
    AD
  };

Constructor & Destructor Documentation

SubProblem()

SubProblem::SubProblem

(

const InputParameters &

parameters

)

Definition at line 49 of file SubProblem.C.

  : Problem(parameters),
    _factory(_app.getFactory()),
    _default_ghosting(getParam<bool>("default_ghosting")),
    _currently_computing_jacobian(false),
    _currently_computing_residual_and_jacobian(false),
    _computing_nonlinear_residual(false),
    _currently_computing_residual(false),
    _safe_access_tagged_matrices(false),
    _safe_access_tagged_vectors(false),
    _have_ad_objects(false),
    _show_functors(false),
    _show_chain_control_data(false),
    _typed_vector_tags(2)
{
  unsigned int n_threads = numThreads();
  _active_elemental_moose_variables.resize(n_threads);
  _has_active_elemental_moose_variables.resize(n_threads);
 
  _active_fe_var_coupleable_matrix_tags.resize(n_threads);
  _active_fe_var_coupleable_vector_tags.resize(n_threads);
  _active_sc_var_coupleable_matrix_tags.resize(n_threads);
  _active_sc_var_coupleable_vector_tags.resize(n_threads);
 
  _functors.resize(n_threads);
  _pbblf_functors.resize(n_threads);
  _functor_to_request_info.resize(n_threads);
}

~SubProblem()

SubProblem::~SubProblem ( )

virtual

Definition at line 78 of file SubProblem.C.

{}

Member Function Documentation

_setCLIOption()

void Problem::_setCLIOption ( )

inlineinherited

For Internal Use.

Definition at line 32 of file Problem.h.

{ _cli_option_found = true; }

addAlgebraicGhostingFunctor()

void SubProblem::addAlgebraicGhostingFunctor	(	libMesh::GhostingFunctor &	algebraic_gf,
		bool	to_mesh = true
	)

Add an algebraic ghosting functor to this problem's DofMaps.

Definition at line 1031 of file SubProblem.C.

{
  EquationSystems & eq = es();
  const auto n_sys = eq.n_systems();
  if (!n_sys)
    return;
 
  eq.get_system(0).get_dof_map().add_algebraic_ghosting_functor(algebraic_gf, to_mesh);
  cloneAlgebraicGhostingFunctor(algebraic_gf, to_mesh);
}

addCachedJacobian()

void SubProblem::addCachedJacobian ( const THREAD_ID  tid )

virtual

Reimplemented in FEProblemBase.

Definition at line 1331 of file SubProblem.C.

{
  assembly(tid, currentNlSysNum()).addCachedJacobian(Assembly::GlobalDataKey{});
}

Referenced by FEProblemBase::addCachedJacobian().

addCachedResidual()

void SubProblem::addCachedResidual ( const THREAD_ID  tid )

virtual

Reimplemented in FEProblemBase.

Definition at line 1310 of file SubProblem.C.

{
  assembly(tid, currentNlSysNum())
      .addCachedResiduals(Assembly::GlobalDataKey{}, currentResidualVectorTags());
}

Referenced by FEProblemBase::addCachedResidual().

addConsumedPropertyName()

void SubProblem::addConsumedPropertyName	(	const MooseObjectName &	obj_name,
		const std::string &	prop_name
	)

Helper for tracking the object that is consuming a property for MaterialPropertyDebugOutput.

Definition at line 728 of file SubProblem.C.

{
  _consumed_material_properties[obj_name].insert(prop_name);
}

Referenced by MaterialPropertyInterface::addConsumedPropertyName().

addCouplingGhostingFunctor()

void SubProblem::addCouplingGhostingFunctor	(	libMesh::GhostingFunctor &	coupling_gf,
		bool	to_mesh = true
	)

Add a coupling functor to this problem's DofMaps.

Definition at line 1064 of file SubProblem.C.

{
  const auto num_nl_sys = numNonlinearSystems();
  if (!num_nl_sys)
    return;
 
  systemBaseNonlinear(0).system().get_dof_map().add_coupling_functor(coupling_gf, to_mesh);
  cloneCouplingGhostingFunctor(coupling_gf, to_mesh);
}

addFunctor()

template<typename T >

void SubProblem::addFunctor	(	const std::string &	name,
		const Moose::FunctorBase< T > &	functor,
		const THREAD_ID	tid
	)

add a functor to the problem functor container

Definition at line 1371 of file SubProblem.h.

{
  constexpr bool added_functor_is_ad =
      !std::is_same<T, typename MetaPhysicL::RawType<T>::value_type>::value;
 
  mooseAssert(tid < _functors.size(), "Too large a thread ID");
 
  auto & functor_to_request_info = _functor_to_request_info[tid];
  auto & functors = _functors[tid];
  auto it = functors.find("wraps_" + name);
  if (it != functors.end())
  {
    // We have this functor already. If it's a null functor, we want to replace it with the valid
    // functor we have now. If it's not then we'll add a new entry into the multimap and then we'll
    // error later if a user requests a functor because their request is ambiguous. This is the
    // reason that the functors container is a multimap: for nice error messages
    auto * const existing_wrapper_base =
        added_functor_is_ad ? std::get<2>(it->second).get() : std::get<1>(it->second).get();
    auto * const existing_wrapper = dynamic_cast<Moose::Functor<T> *>(existing_wrapper_base);
    if (existing_wrapper && existing_wrapper->template wrapsType<Moose::NullFunctor<T>>())
    {
      // Sanity check
      auto [request_info_it, request_info_end_it] = functor_to_request_info.equal_range(name);
      if (request_info_it == request_info_end_it)
        mooseError("We are wrapping a NullFunctor but we don't have any unfilled functor request "
                   "info. This doesn't make sense.");
 
      // Check for valid requests
      while (request_info_it != request_info_end_it)
      {
        auto & [requested_functor_is_ad, requestor_is_ad] = request_info_it->second;
        if (!requested_functor_is_ad && requestor_is_ad && added_functor_is_ad)
          mooseError("We are requesting a non-AD functor '" + name +
                     "' from an AD object, but the true functor is AD. This means we could be "
                     "dropping important derivatives. We will not allow this");
        // We're going to eventually check whether we've fulfilled all functor requests and our
        // check will be that the multimap is empty. This request is fulfilled, so erase it from the
        // map now
        request_info_it = functor_to_request_info.erase(request_info_it);
      }
 
      // Ok we didn't have the functor before, so we will add it now
      std::get<0>(it->second) =
          added_functor_is_ad ? SubProblem::TrueFunctorIs::AD : SubProblem::TrueFunctorIs::NONAD;
      existing_wrapper->assign(functor);
      // Finally we create the non-AD or AD complement of the just added functor
      if constexpr (added_functor_is_ad)
      {
        typedef typename MetaPhysicL::RawType<T>::value_type NonADType;
        auto * const existing_non_ad_wrapper_base = std::get<1>(it->second).get();
        auto * const existing_non_ad_wrapper =
            dynamic_cast<Moose::Functor<NonADType> *>(existing_non_ad_wrapper_base);
        mooseAssert(existing_non_ad_wrapper->template wrapsType<Moose::NullFunctor<NonADType>>(),
                    "Both members of pair should have been wrapping a NullFunctor");
        existing_non_ad_wrapper->assign(
            std::make_unique<Moose::RawValueFunctor<NonADType>>(functor));
      }
      else
      {
        typedef typename Moose::ADType<T>::type ADType;
        auto * const existing_ad_wrapper_base = std::get<2>(it->second).get();
        auto * const existing_ad_wrapper =
            dynamic_cast<Moose::Functor<ADType> *>(existing_ad_wrapper_base);
        mooseAssert(existing_ad_wrapper->template wrapsType<Moose::NullFunctor<ADType>>(),
                    "Both members of pair should have been wrapping a NullFunctor");
        existing_ad_wrapper->assign(std::make_unique<Moose::ADWrapperFunctor<ADType>>(functor));
      }
      return;
    }
    else if (!existing_wrapper)
    {
      // Functor was emplaced but the cast failed. This could be a double definition with
      // different types, or it could be a request with one type then a definition with another
      // type. Either way it is going to error later, but it is cleaner to catch it now
      mooseError("Functor '",
                 name,
                 "' is being added with return type '",
                 MooseUtils::prettyCppType<T>(),
                 "' but it has already been defined or requested with return type '",
                 existing_wrapper_base->returnType(),
                 "'.");
    }
  }
 
  // We are a new functor, create the opposite ADType one and store it with other functors
  if constexpr (added_functor_is_ad)
  {
    typedef typename MetaPhysicL::RawType<T>::value_type NonADType;
    auto new_non_ad_wrapper = std::make_unique<Moose::Functor<NonADType>>(
        std::make_unique<Moose::RawValueFunctor<NonADType>>(functor));
    auto new_ad_wrapper = std::make_unique<Moose::Functor<T>>(functor);
    _functors[tid].emplace("wraps_" + name,
                           std::make_tuple(SubProblem::TrueFunctorIs::AD,
                                           std::move(new_non_ad_wrapper),
                                           std::move(new_ad_wrapper)));
  }
  else
  {
    typedef typename Moose::ADType<T>::type ADType;
    auto new_non_ad_wrapper = std::make_unique<Moose::Functor<T>>((functor));
    auto new_ad_wrapper = std::make_unique<Moose::Functor<ADType>>(
        std::make_unique<Moose::ADWrapperFunctor<ADType>>(functor));
    _functors[tid].emplace("wraps_" + name,
                           std::make_tuple(SubProblem::TrueFunctorIs::NONAD,
                                           std::move(new_non_ad_wrapper),
                                           std::move(new_ad_wrapper)));
  }
}

Referenced by FEProblemBase::addFunction(), addPiecewiseByBlockLambdaFunctor(), and FEProblemBase::addUserObject().

addGhostedBoundary()

virtual void SubProblem::addGhostedBoundary ( BoundaryID  boundary_id )

pure virtual

Will make sure that all necessary elements from boundary_id are ghosted to this processor.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by GeometricSearchData::getNearestNodeLocator(), GeometricSearchData::getNearestNodeLocator(), GeometricSearchData::getPenetrationLocator(), GeometricSearchData::getQuadratureNearestNodeLocator(), and GeometricSearchData::getQuadraturePenetrationLocator().

addGhostedElem()

virtual void SubProblem::addGhostedElem ( dof_id_type  elem_id )

pure virtual

Will make sure that all dofs connected to elem_id are ghosted to this processor.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by NearestNodeLocator::findNodes(), EqualValueBoundaryConstraint::ghostPrimary(), LinearNodalConstraint::LinearNodalConstraint(), and NearestNodeLocator::updateGhostedElems().

addJacobian()

virtual void SubProblem::addJacobian ( const THREAD_ID  tid )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

addJacobianLowerD()

virtual void SubProblem::addJacobianLowerD ( const THREAD_ID  tid )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

addJacobianNeighbor() [1/2]

virtual void SubProblem::addJacobianNeighbor ( const THREAD_ID  tid )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

addJacobianNeighbor() [2/2]

virtual void SubProblem::addJacobianNeighbor ( libMesh::SparseMatrix< libMesh::Number > &  jacobian, unsigned int  ivar, unsigned int  jvar, const libMesh::DofMap &  dof_map, std::vector< dof_id_type > &  dof_indices, std::vector< dof_id_type > &  neighbor_dof_indices, const std::set< TagID > &  tags, const THREAD_ID  tid  )

pure virtual

addJacobianNeighborLowerD()

virtual void SubProblem::addJacobianNeighborLowerD ( const THREAD_ID  tid )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

addMatrixTag()

TagID SubProblem::addMatrixTag ( TagName  tag_name )

virtual

Create a Tag.

Tags can be associated with Vectors and Matrices and allow objects (such as Kernels) to arbitrarily contribute values to any set of vectors/matrics

Note: If the tag is already present then this will simply return the TagID of that Tag

Parameters

tag_name

The name of the tag to create, the TagID will get automatically generated

Reimplemented in DisplacedProblem.

Definition at line 303 of file SubProblem.C.

{
  auto tag_name_upper = MooseUtils::toUpper(tag_name);
  auto existing_tag = _matrix_tag_name_to_tag_id.find(tag_name_upper);
  if (existing_tag == _matrix_tag_name_to_tag_id.end())
  {
    auto tag_id = _matrix_tag_name_to_tag_id.size();
 
    _matrix_tag_name_to_tag_id[tag_name_upper] = tag_id;
 
    _matrix_tag_id_to_tag_name[tag_id] = tag_name_upper;
  }
 
  return _matrix_tag_name_to_tag_id.at(tag_name_upper);
}

Referenced by DisplacedProblem::addMatrixTag(), FEProblemBase::createTagMatrices(), LinearSystem::LinearSystem(), NonlinearEigenSystem::NonlinearEigenSystem(), and NonlinearSystemBase::NonlinearSystemBase().

addNotZeroedVectorTag()

void SubProblem::addNotZeroedVectorTag

(

const TagID

tag

)

Adds a vector tag to the list of vectors that will not be zeroed when other tagged vectors are.

Parameters

tag	the TagID of the vector that will be manually managed

Definition at line 141 of file SubProblem.C.

{
  _not_zeroed_tagged_vectors.insert(tag);
}

Referenced by FEProblemBase::createTagVectors().

addPiecewiseByBlockLambdaFunctor()

template<typename T , typename PolymorphicLambda >

const Moose::FunctorBase< T > & SubProblem::addPiecewiseByBlockLambdaFunctor	(	const std::string &	name,
		PolymorphicLambda	my_lammy,
		const std::set< ExecFlagType > &	clearance_schedule,
		const MooseMesh &	mesh,
		const std::set< SubdomainID > &	block_ids,
		const THREAD_ID	tid
	)

Add a functor that has block-wise lambda definitions, e.g.

the evaluations of the functor are based on a user-provided lambda expression.

Parameters

name	The name of the functor to add
my_lammy	The lambda expression that will be called when the functor is evaluated
clearance_schedule	How often to clear functor evaluations. The default value is always, which means that the functor will be re-evaluated every time it is called. If it is something other than always, than cached values may be returned
mesh	The mesh on which this functor operates
block_ids	The blocks on which the lambda expression is defined
tid	The thread on which the functor we are adding will run

Returns

The added functor

Definition at line 1334 of file SubProblem.h.

{
  auto & pbblf_functors = _pbblf_functors[tid];
 
  auto [it, first_time_added] =
      pbblf_functors.emplace(name,
                             std::make_unique<PiecewiseByBlockLambdaFunctor<T>>(
                                 name, my_lammy, clearance_schedule, mesh, block_ids));
 
  auto * functor = dynamic_cast<PiecewiseByBlockLambdaFunctor<T> *>(it->second.get());
  if (!functor)
  {
    if (first_time_added)
      mooseError("This should be impossible. If this was the first time we added the functor, then "
                 "the dynamic cast absolutely should have succeeded");
    else
      mooseError("Attempted to add a lambda functor with the name '",
                 name,
                 "' but another lambda functor of that name returns a different type");
  }
 
  if (first_time_added)
    addFunctor(name, *functor, tid);
  else
    // The functor already exists
    functor->setFunctor(mesh, block_ids, my_lammy);
 
  return *functor;
}

Referenced by FunctorMaterial::addFunctorPropertyByBlocks().

addResidual()

virtual void SubProblem::addResidual ( const THREAD_ID  tid )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

addResidualLower()

virtual void SubProblem::addResidualLower ( const THREAD_ID  tid )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

addResidualNeighbor()

virtual void SubProblem::addResidualNeighbor ( const THREAD_ID  tid )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

addVectorTag()

TagID SubProblem::addVectorTag ( const TagName &  tag_name, const Moose::VectorTagType  type = Moose::VECTOR_TAG_RESIDUAL  )

virtual

Create a Tag.

Tags can be associated with Vectors and Matrices and allow objects (such as Kernels) to arbitrarily contribute values to any set of vectors/matrics

Note: If the tag is already present then this will simply return the TagID of that Tag, but the type must be the same.

Parameters

tag_name	The name of the tag to create, the TagID will get automatically generated
type	The type of the tag

Reimplemented in DisplacedProblem.

Definition at line 84 of file SubProblem.C.

{
  if (type == Moose::VECTOR_TAG_ANY)
    mooseError("Vector tag type cannot be VECTOR_TAG_ANY");
 
  const auto tag_name_upper = MooseUtils::toUpper(tag_name);
 
  // First, see if the tag exists already
  for (const auto & vector_tag : _vector_tags)
  {
    mooseAssert(_vector_tags[vector_tag._id] == vector_tag, "Vector tags index mismatch");
    if (vector_tag._name == tag_name_upper)
    {
      if (vector_tag._type != type)
        mooseError("While attempting to add vector tag with name '",
                   tag_name_upper,
                   "' and type ",
                   type,
                   ",\na tag with the same name but type ",
                   vector_tag._type,
                   " was found.\n\nA tag can only exist with one type.");
 
      return vector_tag._id;
    }
  }
 
  // Doesn't exist - create it
  const TagID new_tag_id = _vector_tags.size();
  const TagTypeID new_tag_type_id = _typed_vector_tags[type].size();
  // Primary storage for all tags where the index in the vector == the tag ID
  _vector_tags.emplace_back(new_tag_id, new_tag_type_id, tag_name_upper, type);
  // Secondary storage for each type so that we can have quick access to all tags of a type
  _typed_vector_tags[type].emplace_back(new_tag_id, new_tag_type_id, tag_name_upper, type);
  // Name map storage for quick name access
  _vector_tags_name_map.emplace(tag_name_upper, new_tag_id);
 
  // Make sure that _vector_tags, _typed_vector_tags, and _vector_tags_name_map are sane
  verifyVectorTags();
 
  return new_tag_id;
}

Referenced by DisplacedProblem::addVectorTag(), PicardSolve::allocateStorage(), SecantSolve::allocateStorage(), SteffensenSolve::allocateStorage(), FEProblemBase::createTagSolutions(), FEProblemBase::createTagVectors(), NonlinearSystemBase::getResidualNonTimeVector(), NonlinearSystemBase::getResidualTimeVector(), LinearSystem::LinearSystem(), SystemBase::needSolutionState(), NonlinearEigenSystem::NonlinearEigenSystem(), and NonlinearSystemBase::NonlinearSystemBase().

assembly() [1/2]

virtual const Assembly & SubProblem::assembly ( const THREAD_ID  tid, const unsigned int  sys_num  ) const

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

assembly() [2/2]

virtual Assembly & SubProblem::assembly ( const THREAD_ID  tid, const unsigned int  sys_num  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by addCachedJacobian(), addCachedResidual(), cacheJacobian(), cacheJacobianNeighbor(), cacheResidual(), cacheResidualNeighbor(), GeometricSearchData::generateQuadratureNodes(), Moose::globalDofIndexToDerivative(), NonlinearSystemBase::initialSetup(), SystemBase::prepareFace(), preparePRefinement(), reinitElemFaceRef(), reinitFVFace(), reinitLowerDElem(), reinitMortarElem(), reinitNeighborFaceRef(), reinitNeighborLowerDElem(), setCurrentBoundaryID(), setCurrentLowerDElem(), and GeometricSearchData::updateQuadratureNodes().

automaticScaling() [1/2]

bool SubProblem::automaticScaling

(

)

const

Automatic scaling getter.

Returns

A boolean representing whether we are performing automatic scaling

Definition at line 1170 of file SubProblem.C.

{
  // Currently going to assume that we are applying or not applying automatic scaling consistently
  // across nonlinear systems
  return systemBaseNonlinear(0).automaticScaling();
}

Referenced by FEProblemBase::automaticScaling(), and DisplacedProblem::DisplacedProblem().

automaticScaling() [2/2]

void SubProblem::automaticScaling ( bool  automatic_scaling )

virtual

Automatic scaling setter.

Parameters

automatic_scaling

A boolean representing whether we are performing automatic scaling

Reimplemented in FEProblemBase, and FEProblemBase.

Definition at line 1163 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    systemBaseNonlinear(nl_sys_num).automaticScaling(automatic_scaling);
}

cacheJacobian()

void SubProblem::cacheJacobian ( const THREAD_ID  tid )

virtual

Reimplemented in FEProblemBase.

Definition at line 1317 of file SubProblem.C.

{
  assembly(tid, currentNlSysNum()).cacheJacobian(Assembly::GlobalDataKey{});
  if (hasNonlocalCoupling())
    assembly(tid, currentNlSysNum()).cacheJacobianNonlocal(Assembly::GlobalDataKey{});
}

Referenced by FEProblemBase::cacheJacobian().

cacheJacobianNeighbor()

void SubProblem::cacheJacobianNeighbor ( const THREAD_ID  tid )

virtual

Reimplemented in FEProblemBase.

Definition at line 1325 of file SubProblem.C.

{
  assembly(tid, currentNlSysNum()).cacheJacobianNeighbor(Assembly::GlobalDataKey{});
}

Referenced by FEProblemBase::cacheJacobianNeighbor().

cacheResidual()

void SubProblem::cacheResidual ( const THREAD_ID  tid )

virtual

Reimplemented in FEProblemBase.

Definition at line 1296 of file SubProblem.C.

{
  assembly(tid, currentNlSysNum())
      .cacheResidual(Assembly::GlobalDataKey{}, currentResidualVectorTags());
}

Referenced by FEProblemBase::cacheResidual().

cacheResidualNeighbor()

void SubProblem::cacheResidualNeighbor ( const THREAD_ID  tid )

virtual

Reimplemented in FEProblemBase.

Definition at line 1303 of file SubProblem.C.

{
  assembly(tid, currentNlSysNum())
      .cacheResidualNeighbor(Assembly::GlobalDataKey{}, currentResidualVectorTags());
}

Referenced by FEProblemBase::cacheResidualNeighbor().

callMooseError() [1/2]

void MooseBase::callMooseError ( MooseApp *const  app, const InputParameters &  params, std::string  msg, const bool  with_prefix, const hit::Node *  node, const bool  show_trace = true  )

staticinherited

External method for calling moose error with added object context.

Needed so that objects without the MooseBase context (InputParameters) can call errors with context

Parameters

app	The app pointer (if available); adds multiapp context and clears the console
params	The parameters, needed to obtain object information
msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 114 of file MooseBase.C.

{
  if (!node)
    node = MooseBase::getHitNode(params);
 
  std::string multiapp_prefix = "";
  if (app)
  {
    if (!app->isUltimateMaster())
      multiapp_prefix = app->name();
    app->getOutputWarehouse().mooseConsole();
  }
 
  if (with_prefix)
    // False here because the hit context will get processed by the node
    msg = messagePrefix(params, false) + msg;
 
  moose::internal::mooseErrorRaw(msg, multiapp_prefix, node, show_trace);
}

callMooseError() [2/2]

void MooseBase::callMooseError ( std::string  msg, const bool  with_prefix, const hit::Node *  node = nullptr, const bool  show_trace = true  ) const

inherited

External method for calling moose error with added object context.

Parameters

msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 105 of file MooseBase.C.

{
  callMooseError(&_app, _pars, msg, with_prefix, node, show_trace);
}

Referenced by MooseBase::callMooseError(), InputParameters::callMooseError(), MooseBase::mooseDocumentedError(), MooseBase::mooseError(), and MooseBase::mooseErrorNonPrefixed().

checkBlockMatProps()

void SubProblem::checkBlockMatProps ( )

virtual

Checks block material properties integrity.

See also

FEProblemBase::checkProblemIntegrity

Definition at line 615 of file SubProblem.C.

{
  // Variable for storing all available blocks/boundaries from the mesh
  std::set<SubdomainID> all_ids(mesh().meshSubdomains());
 
  std::stringstream errors;
 
  // Loop through the properties to check
  for (const auto & check_it : _map_block_material_props_check)
  {
    // The current id for the property being checked (BoundaryID || BlockID)
    SubdomainID check_id = check_it.first;
 
    std::set<SubdomainID> check_ids = {check_id};
 
    // Loop through all the block/boundary ids
    for (const auto & id : check_ids)
    {
      // Loop through all the stored properties
      for (const auto & prop_it : check_it.second)
      {
        // Produce an error if the material property is not defined on the current block/boundary
        // and any block/boundary
        // and not is not a zero material property.
        if (_map_block_material_props[id].count(prop_it.second) == 0 &&
            _zero_block_material_props[id].count(prop_it.second) == 0)
        {
          std::string check_name = restrictionSubdomainCheckName(id);
          if (check_name.empty())
            check_name = std::to_string(id);
          errors << "Material property '" << prop_it.second << "', requested by '" << prop_it.first
                 << "' is not defined on block " << check_name << "\n";
        }
      }
    }
  }
 
  if (!errors.str().empty())
    mooseError(errors.str());
}

Referenced by FEProblemBase::checkProblemIntegrity().

checkBoundaryMatProps()

void SubProblem::checkBoundaryMatProps ( )

virtual

Checks boundary material properties integrity.

See also

FEProblemBase::checkProblemIntegrity

Definition at line 657 of file SubProblem.C.

{
  // Variable for storing the value for ANY_BOUNDARY_ID
  BoundaryID any_id = Moose::ANY_BOUNDARY_ID;
 
  // Variable for storing all available blocks/boundaries from the mesh
  std::set<BoundaryID> all_ids(mesh().getBoundaryIDs());
 
  std::stringstream errors;
 
  // Loop through the properties to check
  for (const auto & check_it : _map_boundary_material_props_check)
  {
    // The current id for the property being checked (BoundaryID || BlockID)
    BoundaryID check_id = check_it.first;
 
    // In the case when the material being checked has an ID is set to ANY, then loop through all
    // the possible ids and verify that the material property is defined.
    std::set<BoundaryID> check_ids{check_id};
    if (check_id == any_id)
      check_ids = all_ids;
 
    // Loop through all the block/boundary ids
    for (const auto & id : check_ids)
    {
      // Loop through all the stored properties
      for (const auto & prop_it : check_it.second)
      {
        // Produce an error if the material property is not defined on the current block/boundary
        // and any block/boundary
        // and not is not a zero material property.
        if (_map_boundary_material_props[id].count(prop_it.second) == 0 &&
            _map_boundary_material_props[any_id].count(prop_it.second) == 0 &&
            _zero_boundary_material_props[id].count(prop_it.second) == 0 &&
            _zero_boundary_material_props[any_id].count(prop_it.second) == 0)
        {
          std::string check_name = restrictionBoundaryCheckName(id);
          if (check_name.empty())
            check_name = std::to_string(id);
          errors << "Material property '" << prop_it.second << "', requested by '" << prop_it.first
                 << "' is not defined on boundary " << check_name << "\n";
        }
      }
    }
  }
 
  if (!errors.str().empty())
    mooseError(errors.str());
}

Referenced by FEProblemBase::checkProblemIntegrity().

checkNonlocalCouplingRequirement()

virtual bool SubProblem::checkNonlocalCouplingRequirement ( ) const

pure virtual

Returns

whether there will be nonlocal coupling at any point in the simulation, e.g. whether there are any active \emph or inactive nonlocal kernels or boundary conditions

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by Assembly::addCachedJacobian(), and SystemBase::prepareFace().

checkResidualForNans()

virtual bool SubProblem::checkResidualForNans ( ) const

pure virtual

Whether to check residual for NaN/Inf values.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by TaggingInterface::accumulateTaggedLocalResidual(), and TaggingInterface::assignTaggedLocalResidual().

clearActiveElementalMooseVariables()

void SubProblem::clearActiveElementalMooseVariables ( const THREAD_ID  tid )

virtual

Clear the active elemental MooseVariableFieldBase.

If there are no active variables then they will all be reinited. Call this after finishing the computation that was using a restricted set of MooseVariableFieldBase

Parameters

tid	The thread id

Reimplemented in FEProblemBase.

Definition at line 458 of file SubProblem.C.

{
  _has_active_elemental_moose_variables[tid] = 0;
  _active_elemental_moose_variables[tid].clear();
}

Referenced by FEProblemBase::clearActiveElementalMooseVariables().

clearActiveFEVariableCoupleableMatrixTags()

void SubProblem::clearActiveFEVariableCoupleableMatrixTags ( const THREAD_ID  tid )

virtual

Reimplemented in FEProblemBase.

Definition at line 376 of file SubProblem.C.

{
  _active_fe_var_coupleable_matrix_tags[tid].clear();
}

Referenced by FEProblemBase::clearActiveFEVariableCoupleableMatrixTags().

clearActiveFEVariableCoupleableVectorTags()

void SubProblem::clearActiveFEVariableCoupleableVectorTags ( const THREAD_ID  tid )

virtual

Reimplemented in FEProblemBase.

Definition at line 370 of file SubProblem.C.

{
  _active_fe_var_coupleable_vector_tags[tid].clear();
}

Referenced by FEProblemBase::clearActiveFEVariableCoupleableVectorTags().

clearActiveScalarVariableCoupleableMatrixTags()

void SubProblem::clearActiveScalarVariableCoupleableMatrixTags ( const THREAD_ID  tid )

virtual

Reimplemented in FEProblemBase.

Definition at line 417 of file SubProblem.C.

{
  _active_sc_var_coupleable_matrix_tags[tid].clear();
}

Referenced by FEProblemBase::clearActiveScalarVariableCoupleableMatrixTags().

clearActiveScalarVariableCoupleableVectorTags()

void SubProblem::clearActiveScalarVariableCoupleableVectorTags ( const THREAD_ID  tid )

virtual

Reimplemented in FEProblemBase.

Definition at line 411 of file SubProblem.C.

{
  _active_sc_var_coupleable_vector_tags[tid].clear();
}

Referenced by FEProblemBase::clearActiveScalarVariableCoupleableVectorTags().

clearAllDofIndices()

void SubProblem::clearAllDofIndices

(

)

Clear dof indices from variables in nl and aux systems.

Definition at line 1178 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    systemBaseNonlinear(nl_sys_num).clearAllDofIndices();
  systemBaseAuxiliary().clearAllDofIndices();
}

Referenced by FEProblemBase::solve().

clearDiracInfo()

virtual void SubProblem::clearDiracInfo ( )

pure virtual

Gets called before Dirac Kernels are asked to add the points they are supposed to be evaluated in.

Implemented in DisplacedProblem, and FEProblemBase.

cloneAlgebraicGhostingFunctor()

void SubProblem::cloneAlgebraicGhostingFunctor ( libMesh::GhostingFunctor &  algebraic_gf, bool  to_mesh = true  )

private

Creates (n_sys - 1) clones of the provided algebraic ghosting functor (corresponding to the nonlinear system algebraic ghosting functor), initializes the clone with the appropriate DofMap, and then adds the clone to said DofMap.

Parameters

algebraic_gf	the (nonlinear system's) algebraic ghosting functor to clone
to_mesh	whether the clone should be added to the corresponding DofMap's underlying MeshBase (the underlying MeshBase will be the same for every system held by this object's EquationSystems object)

Definition at line 1009 of file SubProblem.C.

{
  EquationSystems & eq = es();
  const auto n_sys = eq.n_systems();
 
  auto pr = _root_alg_gf_to_sys_clones.emplace(
      &algebraic_gf, std::vector<std::shared_ptr<libMesh::GhostingFunctor>>(n_sys - 1));
  mooseAssert(pr.second, "We are adding a duplicate algebraic ghosting functor");
  auto & clones_vec = pr.first->second;
 
  for (MooseIndex(n_sys) i = 1; i < n_sys; ++i)
  {
    DofMap & dof_map = eq.get_system(i).get_dof_map();
    std::shared_ptr<libMesh::GhostingFunctor> clone_alg_gf = algebraic_gf.clone();
    std::dynamic_pointer_cast<RelationshipManager>(clone_alg_gf)
        ->init(mesh(), *algebraic_gf.get_mesh(), &dof_map);
    dof_map.add_algebraic_ghosting_functor(clone_alg_gf, to_mesh);
    clones_vec[i - 1] = clone_alg_gf;
  }
}

Referenced by addAlgebraicGhostingFunctor().

cloneCouplingGhostingFunctor()

void SubProblem::cloneCouplingGhostingFunctor ( libMesh::GhostingFunctor &  coupling_gf, bool  to_mesh = true  )

private

Creates (n_sys - 1) clones of the provided coupling ghosting functor (corresponding to the nonlinear system coupling ghosting functor), initializes the clone with the appropriate DofMap, and then adds the clone to said DofMap.

Parameters

coupling_gf	the (nonlinear system's) coupling ghosting functor to clone
to_mesh	whether the clone should be added to the corresponding DofMap's underlying MeshBase (the underlying MeshBase will be the same for every system held by this object's EquationSystems object)

Definition at line 1043 of file SubProblem.C.

{
  const std::size_t num_nl_sys = numNonlinearSystems();
 
  auto pr = _root_coupling_gf_to_sys_clones.emplace(
      &coupling_gf, std::vector<std::shared_ptr<libMesh::GhostingFunctor>>(num_nl_sys - 1));
  mooseAssert(pr.second, "We are adding a duplicate coupling functor");
  auto & clones_vec = pr.first->second;
 
  for (const auto i : make_range(std::size_t(1), num_nl_sys))
  {
    DofMap & dof_map = systemBaseNonlinear(i).system().get_dof_map();
    std::shared_ptr<libMesh::GhostingFunctor> clone_coupling_gf = coupling_gf.clone();
    std::dynamic_pointer_cast<RelationshipManager>(clone_coupling_gf)
        ->init(mesh(), *coupling_gf.get_mesh(), &dof_map);
    dof_map.add_coupling_functor(clone_coupling_gf, to_mesh);
    clones_vec[i - 1] = clone_coupling_gf;
  }
}

Referenced by addCouplingGhostingFunctor().

computingNonlinearResid() [1/2]

bool SubProblem::computingNonlinearResid ( ) const

inline

Returns true if the problem is in the process of computing the nonlinear residual.

Definition at line 718 of file SubProblem.h.

{ return _computing_nonlinear_residual; }

computingNonlinearResid() [2/2]

virtual void SubProblem::computingNonlinearResid ( const bool  computing_nonlinear_residual )

inlinevirtual

Set whether or not the problem is in the process of computing the nonlinear residual.

Reimplemented in FEProblemBase, and FEProblemBase.

Definition at line 723 of file SubProblem.h.

  {
    _computing_nonlinear_residual = computing_nonlinear_residual;
  }

computingPreSMOResidual()

virtual bool SubProblem::computingPreSMOResidual ( const unsigned int  nl_sys_num ) const

pure virtual

Returns true if the problem is in the process of computing it's initial residual.

Returns

Whether or not the problem is currently computing the initial residual.

Implemented in DisplacedProblem, and FEProblemBase.

computingScalingJacobian()

virtual bool SubProblem::computingScalingJacobian ( ) const

pure virtual

Getter for whether we're computing the scaling jacobian.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by SystemBase::computingScalingJacobian(), and NEML2Utils::shouldCompute().

computingScalingResidual()

virtual bool SubProblem::computingScalingResidual ( ) const

pure virtual

Getter for whether we're computing the scaling residual.

Implemented in DisplacedProblem, and FEProblemBase.

connectControllableParams()

void MooseBase::connectControllableParams ( const std::string &  parameter, const std::string &  object_type, const std::string &  object_name, const std::string &  object_parameter  ) const

inherited

Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

Parameters

parameter	Name of the controllable parameter of this action
object_type	Type of the object added by this action.
object_name	Name of the object added by this action.
object_parameter	Name of the parameter of the object.

Definition at line 77 of file MooseBase.C.

{
  auto & factory = _app.getFactory();
  auto & ip_warehouse = _app.getInputParameterWarehouse();
 
  MooseObjectParameterName primary_name(uniqueName(), parameter);
  const auto base_type = factory.getValidParams(object_type).getBase();
  MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
  ip_warehouse.addControllableParameterConnection(primary_name, secondary_name);
 
  const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
  for (const auto & tag : tags)
  {
    if (!tag.empty())
    {
      // Only adds the parameter with the different control tags if the derived class
      // properly registers the parameter to its own syntax
      MooseObjectParameterName tagged_name(tag, name(), parameter);
      ip_warehouse.addControllableParameterConnection(
          tagged_name, secondary_name, /*error_on_empty=*/false);
    }
  }
}

console()

const ConsoleStream & Problem::console ( ) const

inlineinherited

Return console handle.

Definition at line 48 of file Problem.h.

{ return _console; }

Referenced by Moose::SlepcSupport::mooseSlepcEPSMonitor(), ComputeLinearFVElementalThread::printBlockExecutionInformation(), ComputeLinearFVFaceThread::printBlockExecutionInformation(), ComputeDiracThread::printBlockExecutionInformation(), ComputeIndicatorThread::printBlockExecutionInformation(), ComputeMarkerThread::printBlockExecutionInformation(), ComputeUserObjectsThread::printBlockExecutionInformation(), NonlinearThread::printBlockExecutionInformation(), NonlinearThread::printBoundaryExecutionInformation(), ComputeFVInitialConditionThread::printGeneralExecutionInformation(), ComputeInitialConditionThread::printGeneralExecutionInformation(), ComputeLinearFVElementalThread::printGeneralExecutionInformation(), ComputeLinearFVFaceThread::printGeneralExecutionInformation(), ComputeDiracThread::printGeneralExecutionInformation(), ComputeElemDampingThread::printGeneralExecutionInformation(), ComputeIndicatorThread::printGeneralExecutionInformation(), ComputeMarkerThread::printGeneralExecutionInformation(), ComputeNodalDampingThread::printGeneralExecutionInformation(), ComputeNodalKernelBCJacobiansThread::printGeneralExecutionInformation(), ComputeNodalKernelBcsThread::printGeneralExecutionInformation(), ComputeNodalKernelJacobiansThread::printGeneralExecutionInformation(), ComputeNodalKernelsThread::printGeneralExecutionInformation(), ComputeNodalUserObjectsThread::printGeneralExecutionInformation(), ComputeUserObjectsThread::printGeneralExecutionInformation(), NonlinearThread::printGeneralExecutionInformation(), and ComputeThreadedGeneralUserObjectsThread::printGeneralExecutionInformation().

converged()

virtual bool SubProblem::converged ( const unsigned int  sys_num )

inlinevirtual

Eventually we want to convert this virtual over to taking a solver system number argument.

We will have to first convert apps to use solverSystemConverged, and then once that is done, we can change this signature. Then we can go through the apps again and convert back to this changed API

Definition at line 116 of file SubProblem.h.

{ return solverSystemConverged(sys_num); }

Referenced by EigenExecutionerBase::inversePowerIteration(), EigenExecutionerBase::nonlinearSolve(), FEProblemSolve::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), DisplacedProblem::solverSystemConverged(), solverSystemConverged(), and AB2PredictorCorrector::step().

couplingMatrix()

virtual const libMesh::CouplingMatrix * SubProblem::couplingMatrix ( const unsigned int  nl_sys_num ) const

pure virtual

The coupling matrix defining what blocks exist in the preconditioning matrix.

Implemented in DisplacedProblem, and FEProblemBase.

currentLinearSysNum()

virtual unsigned int SubProblem::currentLinearSysNum ( ) const

pure virtual

Returns

the current linear system number

Implemented in DisplacedProblem, and FEProblemBase.

currentlyComputingJacobian()

const bool & SubProblem::currentlyComputingJacobian ( ) const

inline

Returns true if the problem is in the process of computing the Jacobian.

Definition at line 695 of file SubProblem.h.

{ return _currently_computing_jacobian; };

Referenced by PenetrationLocator::detectPenetration(), ComputeUserObjectsThread::onBoundary(), ComputeUserObjectsThread::onElement(), FEProblemBase::prepare(), ComputeUserObjectsThread::printBlockExecutionInformation(), reinitElemFaceRef(), NEML2Utils::shouldCompute(), and FEProblemBase::updateMortarMesh().

currentlyComputingResidual()

const bool & SubProblem::currentlyComputingResidual ( ) const

inline

Returns true if the problem is in the process of computing the residual.

Definition at line 731 of file SubProblem.h.

{ return _currently_computing_residual; }

currentlyComputingResidualAndJacobian()

const bool & SubProblem::currentlyComputingResidualAndJacobian ( ) const

inline

Returns true if the problem is in the process of computing the residual and the Jacobian.

Definition at line 1483 of file SubProblem.h.

{
  return _currently_computing_residual_and_jacobian;
}

Referenced by reinitElemFaceRef(), and NEML2Utils::shouldCompute().

currentNlSysNum()

virtual unsigned int SubProblem::currentNlSysNum ( ) const

pure virtual

Returns

the current nonlinear system number

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by addCachedJacobian(), addCachedResidual(), cacheJacobian(), cacheJacobianNeighbor(), cacheResidual(), cacheResidualNeighbor(), MooseVariableScalar::computeAD(), Assembly::computeFaceMap(), FVInterfaceKernel::computeJacobian(), FVInterfaceKernel::computeResidual(), Assembly::computeSinglePointMapAD(), Moose::doDerivatives(), reinitElemFaceRef(), and reinitNeighborFaceRef().

currentResidualVectorTags()

virtual const std::vector< VectorTag > & SubProblem::currentResidualVectorTags ( ) const

pure virtual

Return the residual vector tags we are currently computing.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by addCachedResidual(), cacheResidual(), and cacheResidualNeighbor().

customSetup()

void SubProblem::customSetup ( const ExecFlagType &  exec_type )

virtual

Reimplemented in DisplacedProblem, and FEProblemBase.

Definition at line 1196 of file SubProblem.C.

{
  for (auto & map : _pbblf_functors)
    for (auto & pr : map)
      pr.second->customSetup(exec_type);
}

Referenced by DisplacedProblem::customSetup(), and FEProblemBase::customSetup().

defaultGhosting()

bool SubProblem::defaultGhosting ( )

inline

Whether or not the user has requested default ghosting ot be on.

Definition at line 147 of file SubProblem.h.

{ return _default_ghosting; }

Referenced by DisplacedSystem::DisplacedSystem(), and NonlinearSystemBase::NonlinearSystemBase().

determineSolverSystem()

virtual std::pair< bool, unsigned int > SubProblem::determineSolverSystem ( const std::string &  var_name, bool  error_if_not_found = false  ) const

privatepure virtual

Returns

whether a given variable name is in the solver systems (reflected by the first member of the returned pair which is a boolean) and if so, what solver system number it is in (the second member of the returned pair; if the variable is not in the solver systems, then this will be an invalid unsigned integer)

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by getVariableHelper().

diracKernelInfo()

DiracKernelInfo & SubProblem::diracKernelInfo ( )

virtual

Definition at line 740 of file SubProblem.C.

{
  return _dirac_kernel_info;
}

doingPRefinement()

bool SubProblem::doingPRefinement

(

)

const

Returns

whether we're doing p-refinement

Definition at line 1345 of file SubProblem.C.

{
  return mesh().doingPRefinement();
}

Referenced by ElementAdaptivityLevelAux::ElementAdaptivityLevelAux(), ElementLpNormAux::ElementLpNormAux(), InternalSideIndicatorBase::InternalSideIndicatorBase(), FEProblemBase::meshChanged(), and VolumeAux::VolumeAux().

enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 49 of file MooseObject.h.

{ return _enabled; }

Referenced by EigenKernel::enabled(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), and NodeFaceConstraint::validParams().

errorPrefix()

std::string MooseBase::errorPrefix ( const std::string &  ) const

inlineinherited

Deprecated message prefix; the error type is no longer used.

Definition at line 264 of file MooseBase.h.

{ return messagePrefix(); }

es()

virtual libMesh::EquationSystems & SubProblem::es ( )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by addAlgebraicGhostingFunctor(), cloneAlgebraicGhostingFunctor(), NumDOFs::NumDOFs(), NumVars::NumVars(), removeAlgebraicGhostingFunctor(), and removeCouplingGhostingFunctor().

finalNonlinearResidual()

Real SubProblem::finalNonlinearResidual ( const unsigned int  nl_sys_num ) const

virtual

Reimplemented in FEProblemBase.

Definition at line 746 of file SubProblem.C.

{
  return 0;
}

Referenced by Residual::getValue().

flagInvalidSolutionInternal()

template<bool warning>

template void SolutionInvalidInterface::flagInvalidSolutionInternal< false > ( const InvalidSolutionID  invalid_solution_id ) const

protectedinherited

Set solution invalid mark for the given solution ID.

Definition at line 41 of file SolutionInvalidInterface.C.

{
  mooseAssert(
      warning == moose::internal::getSolutionInvalidityRegistry().item(invalid_solution_id).warning,
      "Inconsistent warning flag");
  auto & solution_invalidity = _si_moose_base.getMooseApp().solutionInvalidity();
  if constexpr (!warning)
    if (!_si_problem || _si_problem->immediatelyPrintInvalidSolution())
      solution_invalidity.printDebug(invalid_solution_id);
  return solution_invalidity.flagInvalidSolutionInternal(invalid_solution_id);
}

geomSearchData()

virtual GeometricSearchData & SubProblem::geomSearchData ( )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), NonlinearSystemBase::overwriteNodeFace(), reinitGeomSearch(), and NonlinearSystemBase::setConstraintSecondaryValues().

getActiveElementalMooseVariables()

const std::set< MooseVariableFEBase * > & SubProblem::getActiveElementalMooseVariables ( const THREAD_ID  tid ) const

virtual

Get the MOOSE variables to be reinited on each element.

Parameters

tid	The thread id

Definition at line 446 of file SubProblem.C.

{
  return _active_elemental_moose_variables[tid];
}

Referenced by SystemBase::prepare(), SystemBase::prepareFace(), FEProblemBase::prepareMaterials(), and SystemBase::reinitElem().

getActiveFEVariableCoupleableMatrixTags()

const std::set< TagID > & SubProblem::getActiveFEVariableCoupleableMatrixTags

(

const THREAD_ID

tid

)

const

Definition at line 382 of file SubProblem.C.

{
  return _active_fe_var_coupleable_matrix_tags[tid];
}

getActiveFEVariableCoupleableVectorTags()

const std::set< TagID > & SubProblem::getActiveFEVariableCoupleableVectorTags

(

const THREAD_ID

tid

)

const

Definition at line 388 of file SubProblem.C.

{
  return _active_fe_var_coupleable_vector_tags[tid];
}

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute().

getActiveScalarVariableCoupleableMatrixTags()

const std::set< TagID > & SubProblem::getActiveScalarVariableCoupleableMatrixTags

(

const THREAD_ID

tid

)

const

Definition at line 423 of file SubProblem.C.

{
  return _active_sc_var_coupleable_matrix_tags[tid];
}

Referenced by MooseVariableScalar::reinit().

getActiveScalarVariableCoupleableVectorTags()

const std::set< TagID > & SubProblem::getActiveScalarVariableCoupleableVectorTags

(

const THREAD_ID

tid

)

const

Definition at line 429 of file SubProblem.C.

{
  return _active_sc_var_coupleable_vector_tags[tid];
}

getActualFieldVariable()

virtual MooseVariableFieldBase & SubProblem::getActualFieldVariable ( const THREAD_ID  tid, const std::string &  var_name  )

pure virtual

Returns the variable reference for requested MooseVariableField which may be in any system.

Implemented in DisplacedProblem, and FEProblemBase.

getArrayVariable()

virtual ArrayMooseVariable & SubProblem::getArrayVariable ( const THREAD_ID  tid, const std::string &  var_name  )

pure virtual

Returns the variable reference for requested ArrayMooseVariable which may be in any system.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by AllLocalDofIndicesThread::AllLocalDofIndicesThread(), ArrayIntegratedBC::ArrayIntegratedBC(), and ArrayKernel::ArrayKernel().

getAxisymmetricRadialCoord()

unsigned int SubProblem::getAxisymmetricRadialCoord

(

)

const

Returns the desired radial direction for RZ coordinate transformation.

Returns

The coordinate direction for the radial direction

Definition at line 788 of file SubProblem.C.

{
  return mesh().getAxisymmetricRadialCoord();
}

getBase()

const std::string & MooseBase::getBase ( ) const

inlineinherited

Returns

The registered base for this object (set via InputParameters::registerBase())

Definition at line 147 of file MooseBase.h.

{ return _pars.getBase(); }

Referenced by MooseBase::uniqueParameterName().

getCheckedPointerParam()

template<typename T >

T MooseBase::getCheckedPointerParam ( const std::string &  name, const std::string &  error_string = ""  ) const

inherited

Verifies that the requested parameter exists and is not NULL and returns it to the caller.

The template parameter must be a pointer or an error will be thrown.

Definition at line 450 of file MooseBase.h.

{
  return _pars.getCheckedPointerParam<T>(name, error_string);
}

getConsumedPropertyMap()

const std::map< MooseObjectName, std::set< std::string > > & SubProblem::getConsumedPropertyMap

(

)

const

Return the map that tracks the object with consumed material properties.

Definition at line 734 of file SubProblem.C.

{
  return _consumed_material_properties;
}

Referenced by MaterialPropertyDebugOutput::output().

getCoordSystem()

Moose::CoordinateSystemType SubProblem::getCoordSystem

(

SubdomainID

sid

)

const

Definition at line 1283 of file SubProblem.C.

{
  return mesh().getCoordSystem(sid);
}

Referenced by BlockRestrictable::getBlockCoordSystem(), MultiApp::getBoundingBox(), Assembly::reinitLowerDElem(), Assembly::reinitNeighborLowerDElem(), and Assembly::setCoordinateTransformation().

getDataFileName()

std::string DataFileInterface::getDataFileName ( const std::string &  param ) const

inherited

Deprecated method.

The data file paths are now automatically set within the InputParameters object, so using getParam<DataFileName>("param_name") is now sufficient.

Definition at line 21 of file DataFileInterface.C.

{
  _parent.mooseDeprecated("getDataFileName() is deprecated. The file path is now directly set "
                          "within the InputParameters.\nUse getParam<DataFileName>(\"",
                          param,
                          "\") instead.");
  return _parent.getParam<DataFileName>(param);
}

getDataFileNameByName()

std::string DataFileInterface::getDataFileNameByName ( const std::string &  relative_path ) const

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

{
  _parent.mooseDeprecated("getDataFileNameByName() is deprecated. Use getDataFilePath(\"",
                          relative_path,
                          "\") instead.");
  return getDataFilePath(relative_path);
}

getDataFilePath()

std::string DataFileInterface::getDataFilePath ( const std::string &  relative_path ) const

inherited

Returns the path of a data file for a given relative file path.

This can be used for hardcoded datafile names and will search the same locations as getDataFileName

Definition at line 40 of file DataFileInterface.C.

{
  // This should only ever be used with relative paths. There is no point to
  // use this search path with an absolute path.
  if (std::filesystem::path(relative_path).is_absolute())
    _parent.mooseWarning("While using getDataFilePath(\"",
                         relative_path,
                         "\"): This API should not be used for absolute paths.");
 
  // This will search the data paths for this relative path
  std::optional<std::string> error;
  Moose::DataFileUtils::Path found_path;
  {
    // Throw on error so that if getPath() fails, we can throw an error
    // with the context of _parent.mooseError()
    Moose::ScopedThrowOnError scoped_throw_on_error;
 
    try
    {
      found_path = Moose::DataFileUtils::getPath(relative_path);
    }
    catch (std::exception & e)
    {
      error = e.what();
    }
  }
 
  if (error)
    _parent.mooseError(*error);
 
  mooseAssert(found_path.context == Moose::DataFileUtils::Context::DATA,
              "Should only ever obtain data");
  mooseAssert(found_path.data_name, "Should be set");
 
  const std::string msg =
      "Using data file '" + found_path.path + "' from " + *found_path.data_name + " data";
  _parent.mooseInfo(msg);
 
  return found_path.path;
}

Referenced by DataFileInterface::getDataFileNameByName().

getDiracElements()

virtual void SubProblem::getDiracElements ( std::set< const Elem * > &  elems )

pure virtual

Fills "elems" with the elements that should be looped over for Dirac Kernels.

Implemented in DisplacedProblem, and FEProblemBase.

getFunctor()

template<typename T >

const Moose::Functor< T > & SubProblem::getFunctor	(	const std::string &	name,
		const THREAD_ID	tid,
		const std::string &	requestor_name,
		bool	requestor_is_ad
	)

Template Parameters

T	The type that the functor will return when evaluated, e.g. ADReal or Real

Parameters

name	The name of the functor to retrieve
tid	The thread ID that we are retrieving the functor property for
requestor_name	The name of the object that is requesting this functor property
requestor_is_ad	Whether the requesting object is an AD object

Returns

a constant reference to the functor

Definition at line 1210 of file SubProblem.h.

{
  mooseAssert(tid < _functors.size(), "Too large a thread ID");
 
  // Log the requestor
  _functor_to_requestors["wraps_" + name].insert(requestor_name);
 
  constexpr bool requested_functor_is_ad =
      !std::is_same<T, typename MetaPhysicL::RawType<T>::value_type>::value;
 
  auto & functor_to_request_info = _functor_to_request_info[tid];
 
  // Get the requested functor if we already have it
  auto & functors = _functors[tid];
  if (auto find_ret = functors.find("wraps_" + name); find_ret != functors.end())
  {
    if (functors.count("wraps_" + name) > 1)
      mooseError("Attempted to get a functor with the name '",
                 name,
                 "' but multiple (" + std::to_string(functors.count("wraps_" + name)) +
                     ") functors match. Make sure that you do not have functor material "
                     "properties, functions, postprocessors or variables with the same names.");
 
    auto & [true_functor_is, non_ad_functor, ad_functor] = find_ret->second;
    auto & functor_wrapper = requested_functor_is_ad ? *ad_functor : *non_ad_functor;
 
    auto * const functor = dynamic_cast<Moose::Functor<T> *>(&functor_wrapper);
    if (!functor)
      mooseError("A call to SubProblem::getFunctor requested a functor named '",
                 name,
                 "' that returns the type: '",
                 libMesh::demangle(typeid(T).name()),
                 "'. However, that functor already exists and returns a different type: '",
                 functor_wrapper.returnType(),
                 "'");
 
    if (functor->template wrapsType<Moose::NullFunctor<T>>())
      // Store for future checking when the actual functor gets added
      functor_to_request_info.emplace(name,
                                      std::make_pair(requested_functor_is_ad, requestor_is_ad));
    else
    {
      // We already have the actual functor
      if (true_functor_is == SubProblem::TrueFunctorIs::UNSET)
        mooseError("We already have the functor; it should not be unset");
 
      // Check for whether this is a valid request
      // We allow auxiliary variables and linear variables to be retrieved as non AD
      if (!requested_functor_is_ad && requestor_is_ad &&
          true_functor_is == SubProblem::TrueFunctorIs::AD &&
          !(hasAuxiliaryVariable(name) || hasLinearVariable(name)))
        mooseError("The AD object '",
                   requestor_name,
                   "' is requesting the functor '",
                   name,
                   "' as a non-AD functor even though it is truly an AD functor, which is not "
                   "allowed, since this may unintentionally drop derivatives.");
    }
 
    return *functor;
  }
 
  // We don't have the functor yet but we could have it in the future. We'll create null functors
  // for now
  functor_to_request_info.emplace(name, std::make_pair(requested_functor_is_ad, requestor_is_ad));
  if constexpr (requested_functor_is_ad)
  {
    typedef typename MetaPhysicL::RawType<T>::value_type NonADType;
    typedef T ADType;
 
    auto emplace_ret =
        functors.emplace("wraps_" + name,
                         std::make_tuple(SubProblem::TrueFunctorIs::UNSET,
                                         std::make_unique<Moose::Functor<NonADType>>(
                                             std::make_unique<Moose::NullFunctor<NonADType>>()),
                                         std::make_unique<Moose::Functor<ADType>>(
                                             std::make_unique<Moose::NullFunctor<ADType>>())));
 
    return cast_ref<Moose::Functor<T> &>(*(requested_functor_is_ad
                                               ? std::get<2>(emplace_ret->second)
                                               : std::get<1>(emplace_ret->second)));
  }
  else
  {
    typedef T NonADType;
    typedef typename Moose::ADType<T>::type ADType;
 
    auto emplace_ret =
        functors.emplace("wraps_" + name,
                         std::make_tuple(SubProblem::TrueFunctorIs::UNSET,
                                         std::make_unique<Moose::Functor<NonADType>>(
                                             std::make_unique<Moose::NullFunctor<NonADType>>()),
                                         std::make_unique<Moose::Functor<ADType>>(
                                             std::make_unique<Moose::NullFunctor<ADType>>())));
 
    return cast_ref<Moose::Functor<T> &>(*(requested_functor_is_ad
                                               ? std::get<2>(emplace_ret->second)
                                               : std::get<1>(emplace_ret->second)));
  }
}

Referenced by FunctorInterface::getFunctorByName().

getHitNode() [1/2]

const hit::Node * MooseBase::getHitNode ( ) const

inlineinherited

Returns

The block-level hit node for this object, if any

Definition at line 136 of file MooseBase.h.

{ return getHitNode(_pars); }

Referenced by MooseBase::callMooseError(), MooseBase::getHitNode(), and MooseBase::messagePrefix().

getHitNode() [2/2]

const hit::Node * MooseBase::getHitNode ( const InputParameters &  params )

staticprivateinherited

Internal method for getting a hit node (if available) given a set of parameters.

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 167 of file MooseBase.C.

{
  if (const auto hit_node = params.getHitNode())
    if (!hit_node->isRoot())
      return hit_node;
  return nullptr;
}

getLineSearch()

virtual LineSearch * SubProblem::getLineSearch ( )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

getMaterialPropertyBlockNames()

std::vector< SubdomainName > SubProblem::getMaterialPropertyBlockNames ( const std::string &  prop_name )

virtual

Get a vector of block id equivalences that the material property is defined on.

Definition at line 481 of file SubProblem.C.

{
  std::set<SubdomainID> blocks = getMaterialPropertyBlocks(prop_name);
  std::vector<SubdomainName> block_names;
  block_names.reserve(blocks.size());
  for (const auto & block_id : blocks)
  {
    SubdomainName name;
    name = mesh().getMesh().subdomain_name(block_id);
    if (name.empty())
    {
      std::ostringstream oss;
      oss << block_id;
      name = oss.str();
    }
    block_names.push_back(name);
  }
 
  return block_names;
}

Referenced by MaterialPropertyInterface::getMaterialPropertyBlockNames().

getMaterialPropertyBlocks()

std::set< SubdomainID > SubProblem::getMaterialPropertyBlocks ( const std::string &  prop_name )

virtual

Get a vector containing the block ids the material property is defined on.

Definition at line 465 of file SubProblem.C.

{
  std::set<SubdomainID> blocks;
 
  for (const auto & it : _map_block_material_props)
  {
    const std::set<std::string> & prop_names = it.second;
    std::set<std::string>::iterator name_it = prop_names.find(prop_name);
    if (name_it != prop_names.end())
      blocks.insert(it.first);
  }
 
  return blocks;
}

Referenced by getMaterialPropertyBlockNames(), and MaterialPropertyInterface::getMaterialPropertyBlocks().

getMaterialPropertyBoundaryIDs()

std::set< BoundaryID > SubProblem::getMaterialPropertyBoundaryIDs ( const std::string &  prop_name )

virtual

Get a vector containing the block ids the material property is defined on.

Definition at line 517 of file SubProblem.C.

{
  std::set<BoundaryID> boundaries;
 
  for (const auto & it : _map_boundary_material_props)
  {
    const std::set<std::string> & prop_names = it.second;
    std::set<std::string>::iterator name_it = prop_names.find(prop_name);
    if (name_it != prop_names.end())
      boundaries.insert(it.first);
  }
 
  return boundaries;
}

Referenced by MaterialPropertyInterface::getMaterialPropertyBoundaryIDs(), and getMaterialPropertyBoundaryNames().

getMaterialPropertyBoundaryNames()

std::vector< BoundaryName > SubProblem::getMaterialPropertyBoundaryNames ( const std::string &  prop_name )

virtual

Get a vector of block id equivalences that the material property is defined on.

Definition at line 533 of file SubProblem.C.

{
  std::set<BoundaryID> boundaries = getMaterialPropertyBoundaryIDs(prop_name);
  std::vector<BoundaryName> boundary_names;
  boundary_names.reserve(boundaries.size());
  const BoundaryInfo & boundary_info = mesh().getMesh().get_boundary_info();
 
  for (const auto & bnd_id : boundaries)
  {
    BoundaryName name;
    if (bnd_id == Moose::ANY_BOUNDARY_ID)
      name = "ANY_BOUNDARY_ID";
    else
    {
      name = boundary_info.get_sideset_name(bnd_id);
      if (name.empty())
      {
        std::ostringstream oss;
        oss << bnd_id;
        name = oss.str();
      }
    }
    boundary_names.push_back(name);
  }
 
  return boundary_names;
}

Referenced by MaterialPropertyInterface::getMaterialPropertyBoundaryNames().

getMatrixTagID()

TagID SubProblem::getMatrixTagID ( const TagName &  tag_name ) const

virtual

Get a TagID from a TagName.

Reimplemented in DisplacedProblem.

Definition at line 334 of file SubProblem.C.

{
  auto tag_name_upper = MooseUtils::toUpper(tag_name);
 
  if (!matrixTagExists(tag_name))
    mooseError("Matrix tag: ",
               tag_name,
               " does not exist. ",
               "If this is a TimeKernel then this may have happened because you didn't "
               "specify a Transient Executioner.");
 
  return _matrix_tag_name_to_tag_id.at(tag_name_upper);
}

Referenced by ScalarCoupleable::coupledMatrixTagScalarValue(), Coupleable::coupledMatrixTagValue(), Coupleable::coupledMatrixTagValues(), ExplicitTimeIntegrator::ExplicitTimeIntegrator(), DisplacedProblem::getMatrixTagID(), TaggingInterface::TaggingInterface(), and TaggingInterface::useMatrixTag().

getMatrixTags()

virtual std::map< TagName, TagID > & SubProblem::getMatrixTags ( )

inlinevirtual

Return all matrix tags in the system, where a tag is represented by a map from name to ID.

Definition at line 256 of file SubProblem.h.

{ return _matrix_tag_name_to_tag_id; }

Referenced by FEProblemBase::computeJacobian(), NonlinearSystemBase::computeJacobian(), EigenProblem::computeJacobianAB(), NonlinearSystemBase::computeJacobianBlocks(), EigenProblem::computeJacobianTag(), FEProblemBase::computeLinearSystemSys(), and FEProblemBase::computeResidualAndJacobian().

getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

{ return _app; }

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), MooseMesh::cacheChangedLists(), ReporterTransferInterface::checkHasReporterValue(), LinearFVGradientManager::checkRestartedGradientHistory(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Coupleable::Coupleable(), MortarInterfaceWarehouse::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), GreaterThanLessThanPostprocessor::execute(), Terminator::execute(), WorkBalance::execute(), FEProblemSolve::FEProblemSolve(), RadialAverage::finalize(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), FEProblemBase::getDistribution(), FEProblemBase::getFunction(), FEProblemBase::getFVInterpolationMethod(), FEProblemBase::getMultiApp(), FEProblemBase::getSampler(), DefaultConvergenceBase::getSharedExecutionerParam(), FEProblemBase::getUserObjectBase(), FEProblemBase::getVectorPostprocessorObjectByName(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseLinearVariableFV< OutputType >::MooseLinearVariableFV(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), numThreads(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), Moose::PetscSupport::PetscOptionsScope::PetscOptionsScope(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), AuxiliarySystem::registerFVGradient(), Reporter::Reporter(), ReporterInterface::reportersAdded(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

getParam() [1/2]

template<typename T >

const T & MooseBase::getParam ( const std::string &  name ) const

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns

The value of the parameter

Definition at line 406 of file MooseBase.h.

{
  return InputParameters::getParamHelper<T>(name, _pars);
}

Referenced by CommonOutputAction::act(), CreateDisplacedProblemAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), CylinderComponent::addMeshGenerators(), FEProblemBase::addOutput(), ArrayParsedAux::ArrayParsedAux(), BicubicSplineFunction::BicubicSplineFunction(), SurfaceDelaunayGeneratorBase::checkBoundaryAndHolesParams(), Console::Console(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DiffusionPhysicsBase::DiffusionPhysicsBase(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), MFEMEigenvaluesPostprocessor::execute(), FEProblemSolve::FEProblemSolve(), SurfaceDelaunayGeneratorBase::fillDelaunayOptions(), ParsedVectorReporter::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), ParsedSubdomainGeneratorBase::functionInitialize(), BlockDeletionGenerator::generate(), BoundaryLayerSubdomainGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FileMeshGenerator::generate(), MeshExtruderGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), GeometricSearchInterface::GeometricSearchInterface(), MooseApp::getCheckpointDirectories(), DataFileInterface::getDataFileName(), ExecutorInterface::getExecutor(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), AdvancedOutput::init(), FixedPointIterationAdaptiveDT::init(), TimeSequenceStepper::init(), AdvancedOutput::initAvailableLists(), AttribThread::initFrom(), AttribExecutionOrderGroup::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh::MooseMesh(), MooseVariableBase::MooseVariableBase(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), PerfGraphOutput::output(), Console::outputSystemInformation(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedElementDeletionGenerator::ParsedElementDeletionGenerator(), ParsedGenerateNodeset::ParsedGenerateNodeset(), ParsedGenerateSideset::ParsedGenerateSideset(), ParsedMaterialTempl< is_ad >::ParsedMaterialTempl(), ParsedNodeTransformGenerator::ParsedNodeTransformGenerator(), ParsedODEKernel::ParsedODEKernel(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedVectorReporter::ParsedVectorReporter(), ProjectSideSetOntoLevelSetGenerator::ProjectSideSetOntoLevelSetGenerator(), ReferenceResidualInterface::ReferenceResidualInterface(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), PetscOutput::solveSetup(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorOfPostprocessors::VectorOfPostprocessors(), and XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve().

getParam() [2/2]

template<typename T1 , typename T2 >

std::vector< std::pair< T1, T2 > > MooseBase::getParam ( const std::string &  param1, const std::string &  param2  ) const

inherited

Retrieve two parameters and provide pair of parameters for the object.

Parameters

param1	The name of first parameter
param2	The name of second parameter

Returns

Vector of pairs of first and second parameters

Definition at line 443 of file MooseBase.h.

{
  return _pars.get<T1, T2>(param1, param2);
}

getRenamedParam()

template<typename T >

const T & MooseBase::getRenamedParam ( const std::string &  old_name, const std::string &  new_name  ) const

inherited

Retrieve a renamed parameter for the object.

This helper makes sure we check both names before erroring, and that only one parameter is passed to avoid silent errors

Parameters

old_name	the old name for the parameter
new_name	the new name for the parameter

Definition at line 420 of file MooseBase.h.

{
  // Most important: accept new parameter
  if (isParamSetByUser(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Second most: accept old parameter
  if (isParamValid(old_name) && !isParamSetByUser(new_name))
    return getParam<T>(old_name);
  // Third most: accept default for new parameter
  if (isParamValid(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Refuse: no default, no value passed
  if (!isParamValid(old_name) && !isParamValid(new_name))
    mooseError("parameter '" + new_name +
               "' is being retrieved without being set.\nDid you misspell it?");
  // Refuse: both old and new parameters set by user
  else
    mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
               old_name + "'");
}

getScalarVariable()

virtual MooseVariableScalar & SubProblem::getScalarVariable ( const THREAD_ID  tid, const std::string &  var_name  )

pure virtual

Returns the scalar variable reference from whichever system contains it.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by Coupleable::Coupleable(), and ScalarCoupleable::ScalarCoupleable().

getSharedPtr() [1/2]

std::shared_ptr< MooseObject > MooseObject::getSharedPtr ( )

inherited

Get another shared pointer to this object that has the same ownership group.

Wrapper around shared_from_this().

Definition at line 70 of file MooseObject.C.

{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}

Referenced by MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), and WebServerControl::addServerAction().

getSharedPtr() [2/2]

std::shared_ptr< const MooseObject > MooseObject::getSharedPtr ( ) const

inherited

Definition at line 83 of file MooseObject.C.

{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}

getStandardVariable()

virtual MooseVariable & SubProblem::getStandardVariable ( const THREAD_ID  tid, const std::string &  var_name  )

pure virtual

Returns the variable reference for requested MooseVariable which may be in any system.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), NodalVariableValue::execute(), IntegratedBC::IntegratedBC(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), Kernel::Kernel(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), NodalBC::NodalBC(), NodalKernel::NodalKernel(), PenetrationThread::operator()(), and MoveNodesByParsedExpressionModifier::setupNodalOutputVariables().

getSystem()

virtual libMesh::System & SubProblem::getSystem ( const std::string &  var_name )

pure virtual

Returns the equation system containing the variable provided.

Implemented in DisplacedProblem, and FEProblemBase.

getVariable() [1/2]

virtual MooseVariableFieldBase & SubProblem::getVariable ( const THREAD_ID  tid, const std::string &  var_name, Moose::VarKindType  expected_var_type = Moose::VarKindType::VAR_ANY, Moose::VarFieldType  expected_var_field_type = Moose::VarFieldType::VAR_FIELD_ANY  )

inlinevirtual

Reimplemented in DisplacedProblem, and FEProblemBase.

Definition at line 282 of file SubProblem.h.

  {
    return const_cast<MooseVariableFieldBase &>(const_cast<const SubProblem *>(this)->getVariable(
        tid, var_name, expected_var_type, expected_var_field_type));
  }

getVariable() [2/2]

virtual const MooseVariableFieldBase & SubProblem::getVariable ( const THREAD_ID  tid, const std::string &  var_name, Moose::VarKindType  expected_var_type = Moose::VarKindType::VAR_ANY, Moose::VarFieldType  expected_var_field_type = Moose::VarFieldType::VAR_FIELD_ANY  ) const

pure virtual

Returns the variable reference for requested variable which must be of the expected_var_type (Nonlinear vs.

Auxiliary) and expected_var_field_type (standard, scalar, vector). The default values of VAR_ANY and VAR_FIELD_ANY should be used when "any" type of variable is acceptable. Throws an error if the variable in question is not in the expected System or of the expected type.

Implemented in DisplacedProblem, FEProblemBase, DisplacedProblem, and FEProblemBase.

Referenced by ADDGKernel::ADDGKernel(), MooseObjectWarehouseBase< T >::addObject(), AllLocalDofIndicesThread::AllLocalDofIndicesThread(), ArrayDGKernel::ArrayDGKernel(), ComboMarker::ComboMarker(), Coupleable::Coupleable(), DGKernel::DGKernel(), getVariable(), IndicatorMarker::IndicatorMarker(), isValid(), MooseVariableInterface< T >::MooseVariableInterface(), ScalarCoupleable::ScalarCoupleable(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), and TimeDerivativeAux::TimeDerivativeAux().

getVariableHelper() [1/2]

template<typename T >

MooseVariableFieldBase & SubProblem::getVariableHelper ( const THREAD_ID  tid, const std::string &  var_name, Moose::VarKindType  expected_var_type, Moose::VarFieldType  expected_var_field_type, const std::vector< T > &  nls, const SystemBase &  aux  ) const

protected

Helper function called by getVariable that handles the logic for checking whether Variables of the requested type are available.

Referenced by DisplacedProblem::getVariable(), and FEProblemBase::getVariable().

getVariableHelper() [2/2]

template<typename T >

MooseVariableFEBase & SubProblem::getVariableHelper	(	const THREAD_ID	tid,
		const std::string &	var_name,
		Moose::VarKindType	expected_var_type,
		Moose::VarFieldType	expected_var_field_type,
		const std::vector< T > &	systems,
		const SystemBase &	aux
	)		const

Definition at line 810 of file SubProblem.C.

{
  // Eventual return value
  MooseVariableFEBase * var = nullptr;
 
  const auto [var_in_sys, sys_num] = determineSolverSystem(var_name);
 
  // First check that the variable is found on the expected system.
  if (expected_var_type == Moose::VarKindType::VAR_ANY)
  {
    if (var_in_sys)
      var = &(systems[sys_num]->getVariable(tid, var_name));
    else if (aux.hasVariable(var_name))
      var = &(aux.getVariable(tid, var_name));
    else
      mooseError("Unknown variable " + var_name);
  }
  else if (expected_var_type == Moose::VarKindType::VAR_SOLVER && var_in_sys &&
           systems[sys_num]->hasVariable(var_name))
    var = &(systems[sys_num]->getVariable(tid, var_name));
  else if (expected_var_type == Moose::VarKindType::VAR_AUXILIARY && aux.hasVariable(var_name))
    var = &(aux.getVariable(tid, var_name));
  else
  {
    std::string expected_var_type_string =
        (expected_var_type == Moose::VarKindType::VAR_SOLVER ? "nonlinear" : "auxiliary");
    mooseError("No ",
               expected_var_type_string,
               " variable named ",
               var_name,
               " found. "
               "Did you specify an auxiliary variable when you meant to specify a nonlinear "
               "variable (or vice-versa)?");
  }
 
  // Now make sure the var found has the expected field type.
  if ((expected_var_field_type == Moose::VarFieldType::VAR_FIELD_ANY) ||
      (expected_var_field_type == var->fieldType()))
    return *var;
  else
  {
    std::string expected_var_field_type_string =
        MooseUtils::toLower(Moose::stringify(expected_var_field_type));
    std::string var_field_type_string = MooseUtils::toLower(Moose::stringify(var->fieldType()));
 
    mooseError("No ",
               expected_var_field_type_string,
               " variable named ",
               var_name,
               " found. "
               "Did you specify a ",
               var_field_type_string,
               " variable when you meant to specify a ",
               expected_var_field_type_string,
               " variable?");
  }
}

getVectorTag()

const VectorTag & SubProblem::getVectorTag ( const TagID  tag_id ) const

virtual

Get a VectorTag from a TagID.

Reimplemented in DisplacedProblem.

Definition at line 153 of file SubProblem.C.

{
  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
 
  if (!vectorTagExists(tag_id))
    mooseError("Vector tag with ID ", tag_id, " does not exist");
 
  return _vector_tags[tag_id];
}

Referenced by FEProblemBase::addCachedResidualDirectly(), Assembly::cacheResidual(), Assembly::cacheResidualNodes(), DisplacedProblem::getVectorTag(), getVectorTags(), TaggingInterface::prepareVectorTagInternal(), TaggingInterface::prepareVectorTagLower(), TaggingInterface::prepareVectorTagNeighbor(), FEProblemBase::setResidual(), and FEProblemBase::setResidualNeighbor().

getVectorTagID()

TagID SubProblem::getVectorTagID ( const TagName &  tag_name ) const

virtual

Get a TagID from a TagName.

Reimplemented in DisplacedProblem.

Definition at line 195 of file SubProblem.C.

{
  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
 
  const auto tag_name_upper = MooseUtils::toUpper(tag_name);
  const auto search = _vector_tags_name_map.find(tag_name_upper);
  if (search != _vector_tags_name_map.end())
    return search->second;
 
  std::string message =
      tag_name_upper == "TIME"
          ? ".\n\nThis may occur if "
            "you have a TimeKernel in your problem but did not specify a transient executioner."
          : "";
  mooseError("Vector tag '", tag_name_upper, "' does not exist", message);
}

Referenced by Coupleable::coupledVectorTagArrayGradient(), Coupleable::coupledVectorTagArrayGradients(), Coupleable::coupledVectorTagArrayValues(), Coupleable::coupledVectorTagDofValues(), Coupleable::coupledVectorTagGradient(), Coupleable::coupledVectorTagGradients(), ScalarCoupleable::coupledVectorTagScalarValue(), Coupleable::coupledVectorTagValues(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), DisplacedProblem::getVectorTagID(), MooseVariableDataBase< OutputType >::MooseVariableDataBase(), ReferenceResidualConvergence::ReferenceResidualConvergence(), SolverSystem::setSolution(), TaggingInterface::TaggingInterface(), TagVectorAux::TagVectorAux(), MultiAppDofCopyTransfer::transfer(), TaggingInterface::useVectorTag(), Coupleable::vectorTagDofValueHelper(), and Coupleable::vectorTagValueHelper().

getVectorTags() [1/2]

const std::vector< VectorTag > & SubProblem::getVectorTags ( const Moose::VectorTagType  type = Moose::VECTOR_TAG_ANY ) const

virtual

Return all vector tags, where a tag is represented by a map from name to ID.

Can optionally be limited to a vector tag type.

Reimplemented in DisplacedProblem.

Definition at line 176 of file SubProblem.C.

{
  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
 
  if (type == Moose::VECTOR_TAG_ANY)
    return _vector_tags;
  else
    return _typed_vector_tags[type];
}

getVectorTags() [2/2]

std::vector< VectorTag > SubProblem::getVectorTags

(

const std::set< TagID > &

tag_ids

)

const

Definition at line 164 of file SubProblem.C.

{
  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
 
  std::vector<VectorTag> tags;
  tags.reserve(tag_ids.size());
  for (const auto & tag_id : tag_ids)
    tags.push_back(getVectorTag(tag_id));
  return tags;
}

Referenced by FEProblemBase::computeLinearSystemSys(), NonlinearSystemBase::computeNodalBCsResidual(), EigenProblem::computeResidualAB(), FEProblemBase::computeResidualAndJacobian(), EigenProblem::computeResidualTag(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), DisplacedProblem::getVectorTags(), numVectorTags(), ComputeMortarFunctor::operator()(), and FEProblemBase::setCurrentResidualVectorTags().

getVectorVariable()

virtual VectorMooseVariable & SubProblem::getVectorVariable ( const THREAD_ID  tid, const std::string &  var_name  )

pure virtual

Returns the variable reference for requested VectorMooseVariable which may be in any system.

Implemented in DisplacedProblem, and FEProblemBase.

ghostedElems()

virtual std::set< dof_id_type > & SubProblem::ghostedElems ( )

inlinevirtual

Return the list of elements that should have their DoFs ghosted to this processor.

Returns

The list

Reimplemented in DisplacedProblem.

Definition at line 683 of file SubProblem.h.

{ return _ghosted_elems; }

Referenced by SystemBase::augmentSendList(), NearestNodeLocator::findNodes(), DisplacedProblem::ghostedElems(), and NearestNodeLocator::updatePatch().

ghostGhostedBoundaries()

virtual void SubProblem::ghostGhostedBoundaries ( )

pure virtual

Causes the boundaries added using addGhostedBoundary to actually be ghosted.

Implemented in DisplacedProblem, and FEProblemBase.

hasActiveElementalMooseVariables()

bool SubProblem::hasActiveElementalMooseVariables ( const THREAD_ID  tid ) const

virtual

Whether or not a list of active elemental moose variables has been set.

Returns

True if there has been a list of active elemental moose variables set, False otherwise

Definition at line 452 of file SubProblem.C.

{
  return _has_active_elemental_moose_variables[tid];
}

Referenced by SystemBase::prepare(), SystemBase::prepareFace(), and SystemBase::reinitElem().

hasAuxiliaryVariable()

bool SubProblem::hasAuxiliaryVariable ( const std::string &  var_name ) const

virtual

Whether or not this problem has this auxiliary variable.

Definition at line 803 of file SubProblem.C.

{
  return systemBaseAuxiliary().hasVariable(var_name);
}

Referenced by FixedPointSolve::findTransformedSystem(), FunctorChangeFunctorMaterialTempl< is_ad >::FunctorChangeFunctorMaterialTempl(), getFunctor(), and NearestNodeValueAux::NearestNodeValueAux().

hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

Returns

Whether or not this object has a registered base (set via InputParameters::registerBase())

Definition at line 142 of file MooseBase.h.

{ return _pars.hasBase(); }

hasBlockMaterialProperty()

bool SubProblem::hasBlockMaterialProperty ( SubdomainID  block_id, const std::string &  prop_name  )

virtual

Check if a material property is defined on a block.

Definition at line 503 of file SubProblem.C.

{
  auto it = _map_block_material_props.find(bid);
  if (it == _map_block_material_props.end())
    return false;
 
  if (it->second.count(prop_name) > 0)
    return true;
  else
    return false;
}

hasBoundaryMaterialProperty()

bool SubProblem::hasBoundaryMaterialProperty ( BoundaryID  boundary_id, const std::string &  prop_name  )

virtual

Check if a material property is defined on a block.

Definition at line 562 of file SubProblem.C.

{
  auto it = _map_boundary_material_props.find(bid);
  if (it == _map_boundary_material_props.end())
    return false;
 
  if (it->second.count(prop_name) > 0)
    return true;
  else
    return false;
}

hasFunctor()

bool SubProblem::hasFunctor	(	const std::string &	name,
		const THREAD_ID	tid
	)		const

checks whether we have a functor corresponding to name on the thread id tid

Definition at line 1275 of file SubProblem.C.

{
  mooseAssert(tid < _functors.size(), "Too large a thread ID");
  auto & functors = _functors[tid];
  return (functors.find("wraps_" + name) != functors.end());
}

Referenced by DiffusionCG::addFEKernels(), and FunctorInterface::isFunctor().

hasFunctorWithType()

template<typename T >

bool SubProblem::hasFunctorWithType	(	const std::string &	name,
		const THREAD_ID	tid
	)		const

checks whether we have a functor of type T corresponding to name on the thread id tid

Definition at line 1316 of file SubProblem.h.

{
  mooseAssert(tid < _functors.size(), "Too large a thread ID");
  auto & functors = _functors[tid];
 
  const auto & it = functors.find("wraps_" + name);
  constexpr bool requested_functor_is_ad =
      !std::is_same<T, typename MetaPhysicL::RawType<T>::value_type>::value;
 
  if (it == functors.end())
    return false;
  else
    return dynamic_cast<Moose::Functor<T> *>(
        requested_functor_is_ad ? std::get<2>(it->second).get() : std::get<1>(it->second).get());
}

hasLinearVariable()

bool SubProblem::hasLinearVariable ( const std::string &  var_name ) const

virtual

Whether or not this problem has this linear variable.

Definition at line 794 of file SubProblem.C.

{
  for (const auto i : make_range(numLinearSystems()))
    if (systemBaseLinear(i).hasVariable(var_name))
      return true;
  return false;
}

Referenced by getFunctor().

hasNonlocalCoupling()

virtual bool SubProblem::hasNonlocalCoupling ( ) const

pure virtual

Whether the simulation has active nonlocal coupling which should be accounted for in the Jacobian.

For this to return true, there must be at least one active nonlocal kernel or boundary condition

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by cacheJacobian().

hasScalarVariable()

virtual bool SubProblem::hasScalarVariable ( const std::string &  var_name ) const

pure virtual

Returns a Boolean indicating whether any system contains a variable with the name provided.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by Coupleable::Coupleable(), and ScalarCoupleable::ScalarCoupleable().

hasVariable()

virtual bool SubProblem::hasVariable ( const std::string &  var_name ) const

pure virtual

Whether or not this problem has the variable.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by Coupleable::Coupleable(), getVariableHelper(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), PenetrationLocator::PenetrationLocator(), ScalarCoupleable::ScalarCoupleable(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MoveNodesByParsedExpressionModifier::setupNodalOutputVariables(), and TimeDerivativeAux::TimeDerivativeAux().

haveADObjects() [1/2]

bool SubProblem::haveADObjects ( ) const

inline

Method for reading wehther we have any ad objects.

Definition at line 782 of file SubProblem.h.

{ return _have_ad_objects; }

haveADObjects() [2/2]

virtual void SubProblem::haveADObjects ( bool  have_ad_objects )

inlinevirtual

Method for setting whether we have any ad objects.

Reimplemented in DisplacedProblem, FEProblemBase, DisplacedProblem, and FEProblemBase.

Definition at line 778 of file SubProblem.h.

{ _have_ad_objects = have_ad_objects; }

Referenced by ADArrayKernel::ADArrayKernel(), ADDGKernel::ADDGKernel(), ADDiracKernel::ADDiracKernel(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADInterfaceKernelTempl< T >::ADInterfaceKernelTempl(), ADKernelTempl< T >::ADKernelTempl(), Assembly::computeADFace(), FVBoundaryCondition::FVBoundaryCondition(), FVInterfaceKernel::FVInterfaceKernel(), FVKernel::FVKernel(), and Assembly::reinitFE().

haveDisplaced()

virtual bool SubProblem::haveDisplaced ( ) const

pure virtual

Whether we have a displaced problem in our simulation.

Implemented in DisplacedProblem, and FEProblemBase.

haveFV()

virtual bool SubProblem::haveFV ( ) const

pure virtual

returns true if this problem includes/needs finite volume functionality.

Implemented in DisplacedProblem, and FEProblemBase.

init()

virtual void Problem::init ( )

pure virtualinherited

Implemented in DisplacedProblem, EigenProblem, FEProblem, and FEProblemBase.

initialSetup()

void SubProblem::initialSetup ( )

virtual

Reimplemented in MFEMProblem, DisplacedProblem, DumpObjectsProblem, and FEProblemBase.

Definition at line 1220 of file SubProblem.C.

{
  if (_show_functors)
  {
    showFunctors();
    showFunctorRequestors();
  }
  if (_show_chain_control_data)
    _console << _app.getChainControlDataSystem().outputChainControlMap() << std::flush;
 
  for (const auto & functors : _functors)
    for (const auto & [functor_wrapper_name, functor_wrapper] : functors)
    {
      const auto & [true_functor_type, non_ad_functor, ad_functor] = functor_wrapper;
      mooseAssert(non_ad_functor->wrapsNull() == ad_functor->wrapsNull(), "These must agree");
      const auto functor_name = removeSubstring(functor_wrapper_name, "wraps_");
      if (non_ad_functor->wrapsNull())
        mooseError(
            "No functor ever provided with name '",
            functor_name,
            "', which was requested by '",
            MooseUtils::join(libmesh_map_find(_functor_to_requestors, functor_wrapper_name), ","),
            "'.");
      if (true_functor_type == TrueFunctorIs::NONAD ? non_ad_functor->ownsWrappedFunctor()
                                                    : ad_functor->ownsWrappedFunctor())
        mooseError("Functor envelopes should not own the functors they wrap, but '",
                   functor_name,
                   "' is owned by the wrapper. Please open a MOOSE issue for help resolving this.");
    }
}

Referenced by DisplacedProblem::initialSetup(), and FEProblemBase::initialSetup().

isKokkosObject()

bool MooseObject::isKokkosObject ( ) const

inlineinherited

Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.

Definition at line 63 of file MooseObject.h.

{ return parameters().isKokkosObject(); }

Referenced by AttribKokkos::initFrom(), BlockRestrictable::initializeBlockRestrictable(), and BoundaryRestrictable::initializeBoundaryRestrictable().

isMatPropRequested()

bool SubProblem::isMatPropRequested ( const std::string &  prop_name ) const

virtual

Find out if a material property has been requested by any object.

Definition at line 722 of file SubProblem.C.

{
  return _material_property_requested.find(prop_name) != _material_property_requested.end();
}

isParamSetByUser()

bool MooseBase::isParamSetByUser ( const std::string &  name ) const

inlineinherited

Test if the supplied parameter is set by a user, as opposed to not set or set to default.

Parameters

name	The name of the parameter to test

Definition at line 205 of file MooseBase.h.

  {
    return _pars.isParamSetByUser(name);
  }

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), MFEMMesh::buildMesh(), MFEMBoundarySubMesh::buildSubMesh(), MFEMDomainSubMesh::buildSubMesh(), SurfaceDelaunayGeneratorBase::checkBoundaryAndHolesParams(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), MFEMNewtonNonlinearSolver::ConstructSolver(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), FileMesh::FileMesh(), FullSolveMultiApp::FullSolveMultiApp(), MeshDiagnosticsGenerator::generate(), OrientSurfaceMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), MFEMEigenproblem::getRHSCoefficient(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), MFEMMesh::init(), PhysicsBase::initializePhysics(), LibtorchNeuralNetControl::initialSetup(), ElementSubdomainModifierBase::initialSetup(), LibtorchNeuralNetControl::loadControlNeuralNetFromFile(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MFEMEigenproblem::MFEMEigenproblem(), MFEMGeneratedMeshGenerator::MFEMGeneratedMeshGenerator(), MFEMVariable::MFEMVariable(), MooseApp::MooseApp(), MortarConstraintBase::MortarConstraintBase(), MoveNodesByParsedExpressionModifier::moveNodes(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::run(), MooseApp::runInputFile(), MooseApp::runInputs(), MooseApp::setMFEMDevice(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), MFEMHypreBoomerAMG::SetSolverParameters(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), SmoothMeshGenerator::SmoothMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SurfaceSubdomainsFromAllNormalsGenerator::SurfaceSubdomainsFromAllNormalsGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), TriToQuadConverter::TriToQuadConverter(), XYFrontalDelaunayGenerator::XYFrontalDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

isParamValid()

bool MooseBase::isParamValid ( const std::string &  name ) const

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 199 of file MooseBase.h.

{ return _pars.isParamValid(name); }

Referenced by GridPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), AddVariableAction::act(), AutoCheckpointAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CopyNodalVarsAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshCompleteAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayVarReductionAux::ArrayVarReductionAux(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), BSplineCurveGenerator::BSplineCurveGenerator(), TimedSubdomainModifier::buildFromFile(), ParsedChainControl::buildFunction(), GeneratedMesh::buildMesh(), MooseMesh::buildTypedMesh(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), SurfaceDelaunayGeneratorBase::checkBoundaryAndHolesParams(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), LibmeshPartitioner::clone(), SampledOutput::cloneMesh(), CombinedVectorPostprocessor::CombinedVectorPostprocessor(), CombinerGenerator::CombinerGenerator(), ComponentJunction::ComponentJunction(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), FEProblemSolve::convergenceSetup(), CopyMeshPartitioner::CopyMeshPartitioner(), CSVReaderVectorPostprocessor::CSVReaderVectorPostprocessor(), CutMeshByLevelSetGeneratorBase::CutMeshByLevelSetGeneratorBase(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), DGKernelBase::DGKernelBase(), DiffusionFluxAux::DiffusionFluxAux(), DiffusionPhysicsBase::DiffusionPhysicsBase(), DomainUserObject::DomainUserObject(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenProblemSolve::EigenProblemSolve(), ElementGenerator::ElementGenerator(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), PIDTransientControl::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), Exodus::Exodus(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), SurfaceDelaunayGeneratorBase::fillDelaunayOptions(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), FunctionDT::FunctionDT(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FVInterfaceKernel::FVInterfaceKernel(), FVMassMatrix::FVMassMatrix(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), AddMetaDataGenerator::generate(), BlockDeletionGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), BSplineCurveGenerator::generate(), ConcentricCircleMeshGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), ElementGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), GeneratedMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ManifoldSubdomainGenerator::generate(), MeshExtruderGenerator::generate(), OrientSurfaceMeshGenerator::generate(), ParsedExtraElementIDGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RenumberBySubdomainGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), SphereMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainPerElementGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), XYZDelaunayGenerator::generate(), PropertyReadFile::getFileNames(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getRenamedParam(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), AddPeriodicBCAction::getVariables(), Terminator::handleMessage(), HFEMDirichletBC::HFEMDirichletBC(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), AdvancedOutput::initAvailableLists(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), SolutionAux::initialSetup(), SolutionScalarAux::initialSetup(), PIDTransientControl::initialSetup(), ParsedConvergence::initialSetup(), EigenProblemSolve::initialSetup(), MooseParsedFunction::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedVectorFunction::initialSetup(), PiecewiseTabularBase::initialSetup(), SolutionIC::initialSetup(), Console::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), PNGOutput::makePNG(), MassMatrix::MassMatrix(), MatCoupledForce::MatCoupledForce(), MeshGeneratorComponent::MeshGeneratorComponent(), MooseApp::MooseApp(), MooseMesh::MooseMesh(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableFV< RealEigenVector >::MooseVariableFV(), MortarConstraintBase::MortarConstraintBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldKDTreeTransferBase::MultiAppGeneralFieldKDTreeTransferBase(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), MultiSystemSolveObject::MultiSystemSolveObject(), NodeSetsGeneratorBase::NodeSetsGeneratorBase(), EigenExecutionerBase::normalizeSolution(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedSubdomainGeneratorBase::ParsedSubdomainGeneratorBase(), PetscOutput::PetscOutput(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), EqualValueBoundaryConstraint::pickPrimaryNode(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularBase::PiecewiseTabularBase(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), EqualValueBoundaryConstraint::populateSecondaryNodes(), MooseMesh::prepare(), MultiApp::readCommandLineArguments(), SolutionUserObjectBase::readExodusIIOrNemesis(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), ReporterPointSource::ReporterPointSource(), PhysicsBase::reportPotentiallyMissedParameters(), ParsedSubdomainMeshGenerator::setBlockName(), MooseMesh::setCoordSystem(), FileOutput::setFileBaseInternal(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), Split::setup(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), SideDiffusiveFluxIntegralTempl< is_ad, T >::SideDiffusiveFluxIntegralTempl(), SideSetsGeneratorBase::SideSetsGeneratorBase(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), SolutionUserObjectBase::SolutionUserObjectBase(), Terminator::Terminator(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), PIDTransientControl::timestepSetup(), MultiAppDofCopyTransfer::transfer(), TransformGenerator::TransformGenerator(), TransientBase::TransientBase(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

isSolveTerminationRequested()

virtual bool Problem::isSolveTerminationRequested ( ) const

inlinevirtualinherited

Check of termination has been requested.

This should be called by transient Executioners in the keepGoing() member.

Definition at line 43 of file Problem.h.

{ return _termination_requested; };

Referenced by WebServerControl::execute(), and TransientBase::keepGoing().

isTransient()

virtual bool SubProblem::isTransient ( ) const

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by FVAdvection::computeQpResidual(), and NumFailedTimeSteps::NumFailedTimeSteps().

jacobianSetup()

void SubProblem::jacobianSetup ( )

virtual

Reimplemented in DisplacedProblem, and FEProblemBase.

Definition at line 1212 of file SubProblem.C.

{
  for (auto & map : _pbblf_functors)
    for (auto & pr : map)
      pr.second->jacobianSetup();
}

Referenced by DisplacedProblem::jacobianSetup(), and FEProblemBase::jacobianSetup().

linearSysNum()

virtual unsigned int SubProblem::linearSysNum ( const LinearSystemName &  linear_sys_name ) const

pure virtual

Returns

the linear system number corresponding to the provided linear_sys_name

Implemented in FEProblemBase, and DisplacedProblem.

markMatPropRequested()

void SubProblem::markMatPropRequested ( const std::string &  prop_name )

virtual

Helper method for adding a material property name to the _material_property_requested set.

Definition at line 716 of file SubProblem.C.

{
  _material_property_requested.insert(prop_name);
}

Referenced by MaterialPropertyInterface::markMatPropRequested(), and MaterialBase::markMatPropRequested().

matrixTagExists() [1/2]

bool SubProblem::matrixTagExists ( const TagName &  tag_name ) const

virtual

Check to see if a particular Tag exists.

Reimplemented in DisplacedProblem.

Definition at line 320 of file SubProblem.C.

{
  auto tag_name_upper = MooseUtils::toUpper(tag_name);
 
  return _matrix_tag_name_to_tag_id.find(tag_name_upper) != _matrix_tag_name_to_tag_id.end();
}

Referenced by SystemBase::addMatrix(), SystemBase::associateMatrixToTag(), ScalarCoupleable::coupledMatrixTagScalarValue(), Coupleable::coupledMatrixTagValue(), Coupleable::coupledMatrixTagValues(), SystemBase::disassociateDefaultMatrixTags(), SystemBase::disassociateMatrixFromTag(), SystemBase::disassociateMatrixFromTag(), SystemBase::getMatrix(), SystemBase::getMatrix(), getMatrixTagID(), SystemBase::matrixTagActive(), DisplacedProblem::matrixTagExists(), DisplacedProblem::matrixTagExists(), SystemBase::removeMatrix(), TaggingInterface::useMatrixTag(), and TaggingInterface::useMatrixTag().

matrixTagExists() [2/2]

bool SubProblem::matrixTagExists ( TagID  tag_id ) const

virtual

Check to see if a particular Tag exists.

Reimplemented in DisplacedProblem.

Definition at line 328 of file SubProblem.C.

{
  return _matrix_tag_id_to_tag_name.find(tag_id) != _matrix_tag_id_to_tag_name.end();
}

matrixTagName()

TagName SubProblem::matrixTagName ( TagID  tag )

virtual

Retrieve the name associated with a TagID.

Reimplemented in DisplacedProblem.

Definition at line 349 of file SubProblem.C.

{
  return _matrix_tag_id_to_tag_name[tag];
}

Referenced by SystemBase::addMatrix(), DisplacedProblem::matrixTagName(), and SystemBase::removeMatrix().

mesh() [1/3]

virtual const MooseMesh & SubProblem::mesh ( ) const

pure virtual

Implemented in MFEMProblem, DisplacedProblem, and FEProblemBase.

mesh() [2/3]

virtual MooseMesh & SubProblem::mesh ( )

pure virtual

Implemented in MFEMProblem, DisplacedProblem, and FEProblemBase.

Referenced by addPiecewiseByBlockLambdaFunctor(), checkBlockMatProps(), checkBoundaryMatProps(), cloneAlgebraicGhostingFunctor(), cloneCouplingGhostingFunctor(), coordTransformFactor(), MortarInterfaceWarehouse::createMortarInterface(), doingPRefinement(), PointValue::execute(), ElemSideNeighborLayersTester::execute(), VerifyElementUniqueID::finalize(), VerifyNodalUniqueID::finalize(), getAxisymmetricRadialCoord(), LayeredBase::getBounds(), getCoordSystem(), getMaterialPropertyBlockNames(), getMaterialPropertyBoundaryNames(), FunctorExtremaPositions::initialize(), FunctorPositions::initialize(), VerifyElementUniqueID::initialize(), VerifyNodalUniqueID::initialize(), LayeredBase::LayeredBase(), Moose::Mortar::loopOverMortarSegments(), MortarUserObjectThread::operator()(), ComputeMortarFunctor::operator()(), restrictionBoundaryCheckName(), and restrictionSubdomainCheckName().

mesh() [3/3]

virtual const MooseMesh & SubProblem::mesh ( bool  use_displaced ) const

pure virtual

Implemented in FEProblemBase.

messagePrefix() [1/2]

std::string MooseBase::messagePrefix ( const bool  hit_prefix = true ) const

inlineinherited

Returns

A prefix to be used in messages that contain the input file location associated with this object (if any) and the name and type of the object.

Definition at line 256 of file MooseBase.h.

  {
    return messagePrefix(_pars, hit_prefix);
  }

Referenced by MooseBase::callMooseError(), MooseBase::errorPrefix(), MooseBase::messagePrefix(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), and MooseBase::mooseWarning().

messagePrefix() [2/2]

std::string MooseBase::messagePrefix ( const InputParameters &  params, const bool  hit_prefix  )

staticprivateinherited

Internal method for getting the message prefix for an object (object type, name, etc).

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 140 of file MooseBase.C.

{
  std::string prefix = "";
 
  if (hit_prefix)
    if (const auto node = MooseBase::getHitNode(params))
      prefix += Moose::hitMessagePrefix(*node);
 
  // Don't have context without type and name
  if (!params.isMooseBaseObject())
    return prefix;
 
  const auto & name = params.getObjectName();
  const std::string base = params.hasBase() ? params.getBase() : "object";
  const bool is_main_app = base == "Application" && name == AppFactory::main_app_name;
  prefix += "The following occurred in the ";
  if (is_main_app)
    prefix += "main " + base;
  else
    prefix += base;
  if (base != params.getObjectName() && name.size() && !is_main_app)
    prefix += " '" + name + "'";
  prefix += " of type " + params.getObjectType() + ".";
  return prefix + "\n\n";
}

mooseDeprecated() [1/2]

template<typename... Args>

void MooseBase::mooseDeprecated ( Args &&...  args ) const

inlineinherited

Emits a deprecation warning prefixed with the object name and type, and a stack trace.

Definition at line 317 of file MooseBase.h.

  {
    moose::internal::mooseDeprecatedStream(
        _console, false, true, true, messagePrefix(true), std::forward<Args>(args)...);
  }

Referenced by MooseApp::addCapability(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), MooseApp::getRecoverFileBase(), MooseApp::hasRecoverFileBase(), MooseApp::MooseApp(), and MooseApp::setupOptions().

mooseDeprecated() [2/2]

template<typename... Args>

void SolutionInvalidInterface::mooseDeprecated ( Args &&...  args ) const

inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseDeprecated(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": deprecation");
  }

Referenced by MultiApp::appProblem(), AddVariableAction::determineType(), MooseMesh::elem(), MooseMesh::elem(), FunctionDT::FunctionDT(), MooseMesh::getBoundariesToElems(), Control::getExecuteOptions(), MooseMesh::isTranslatedPeriodic(), MooseMesh::minPeriodicDistance(), MooseMesh::minPeriodicVector(), MooseMesh::node(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), and MooseMesh::setBoundaryToNormalMap().

mooseDeprecatedNoTrace()

template<typename... Args>

void MooseBase::mooseDeprecatedNoTrace ( Args &&...  args ) const

inlineinherited

Emits a deprecation warning prefixed with the object name and type, and no stack trace.

Definition at line 327 of file MooseBase.h.

  {
    moose::internal::mooseDeprecatedStream(
        _console, false, true, false, messagePrefix(true), std::forward<Args>(args)...);
  }

Referenced by MooseApp::MooseApp().

mooseDocumentedError()

template<typename... Args>

void MooseBase::mooseDocumentedError ( const std::string &  repo_name, const unsigned int  issue_num, Args &&...  args  ) const

inlineinherited

Definition at line 277 of file MooseBase.h.

  {
    callMooseError(moose::internal::formatMooseDocumentedError(
                       repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
                   /* with_prefix = */ true);
  }

Referenced by ManifoldSubdomainGenerator::ManifoldSubdomainGenerator().

mooseError()

template<typename... Args>

void MooseBase::mooseError ( Args &&...  args ) const

inlineinherited

Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

Definition at line 271 of file MooseBase.h.

  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ true);
  }

Referenced by CopyMeshPartitioner::_do_partition(), GridPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), AdaptivityAction::act(), AddBoundsVectorsAction::act(), AddFVICAction::act(), AddICAction::act(), AddMeshGeneratorAction::act(), AddPeriodicBCAction::act(), AddTimeStepperAction::act(), AddVectorPostprocessorAction::act(), ChainControlSetupAction::act(), CheckFVBCAction::act(), CheckIntegrityAction::act(), CombineComponentsMeshes::act(), CommonOutputAction::act(), CreateDisplacedProblemAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), InitProblemAction::act(), MaterialOutputAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), SetupMeshCompleteAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), SplitMeshAction::act(), Action::Action(), AddActionComponentAction::AddActionComponentAction(), PhysicsComponentInterface::addBoundaryConditionsFromComponents(), MooseApp::addCapabilityInternal(), DistributedRectilinearMeshGenerator::addElement(), MooseApp::addExecutor(), addFunctor(), PhysicsComponentInterface::addInitialConditionsFromComponents(), ComponentJunction::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), addPiecewiseByBlockLambdaFunctor(), DistributedRectilinearMeshGenerator::addPoint(), DiracKernelBase::addPointWithValidId(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MooseMesh::addQuadratureNode(), AddActionComponentAction::addRelationshipManagers(), WebServerControl::addServerAction(), AddVariableAction::addVariable(), addVectorTag(), MooseVariableScalar::adUDot(), Output::advancedExecuteOn(), MooseVariableBase::allDofIndices(), MooseApp::appNameToLibName(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), MooseApp::attachRelationshipManagers(), MooseApp::attachRelationshipManagers(), Function::average(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), MooseMesh::buildCoarseningMap(), MultiApp::buildComm(), DistributedRectilinearMeshGenerator::buildCube(), PiecewiseTabularInterface::buildFromFile(), PiecewiseTabularInterface::buildFromJSON(), PiecewiseTabularInterface::buildFromXY(), MooseMesh::buildLowerDMesh(), GeneratedMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), TiledMesh::buildMesh(), MooseMesh::buildRefinementMap(), MaterialBase::buildRequiredMaterials(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), EigenExecutionerBase::chebyshev(), checkBlockMatProps(), PhysicsBase::checkBlockRestrictionIdentical(), ComponentBoundaryConditionInterface::checkBoundaryConditionsAllRequested(), checkBoundaryMatProps(), PhysicsBase::checkComponentType(), IterationCountConvergence::checkConvergence(), MooseMesh::checkCoordinateSystems(), DiffusionLHDGAssemblyHelper::checkCoupling(), DefaultConvergenceBase::checkDuplicateSetSharedExecutionerParams(), MooseMesh::checkDuplicateSubdomainNames(), MaterialBase::checkExecutionStage(), FVFluxBC::checkFaceIntegrity(), FVInterfaceKernel::checkFaceIntegrity(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), EigenExecutionerBase::checkIntegrity(), Eigenvalue::checkIntegrity(), ExplicitTimeIntegrator::checkLinearConvergence(), MooseApp::checkMetaDataIntegrity(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), PostprocessorInterface::checkParam(), Moose::PeriodicBCHelper::checkPeriodicParams(), Sampler::checkReinitStatus(), MultiAppTransfer::checkSiblingsTransferSupported(), MaterialBase::checkStatefulSanity(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Moose::PetscSupport::checkUserProvidedPetscOption(), MultiAppTransfer::checkVariable(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), MooseMesh::clone(), LibmeshPartitioner::clone(), CombinerGenerator::CombinerGenerator(), MooseVariableFieldBase::componentName(), VariableCondensationPreconditioner::computeDInverseDiag(), CompositionDT::computeDT(), MooseVariableFieldBase::computeFaceValues(), TimeStepper::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), MooseMesh::computeFiniteVolumeCoords(), Moose::Kokkos::ResidualObject::computeOffDiagJacobian(), MaterialBase::computeProperties(), ResidualObject::computeResidualAndJacobian(), TimeStepper::computeStep(), AStableDirk4::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), TimeStepper::constrainStep(), LibtorchNeuralNetControl::controlNeuralNet(), TransientBase::convergedToSteadyState(), ParsedConvergence::convertRealToBool(), MooseApp::copyInputs(), CopyMeshPartitioner::CopyMeshPartitioner(), MultiApp::createApp(), MooseApp::createExecutors(), AddVariableAction::createInitialConditionAction(), MooseApp::createRMFromTemplateAndInit(), Function::curl(), ReporterTransferInterface::declareClone(), Moose::Kokkos::MaterialBase::declareKokkosPropertyInternal(), MeshGenerator::declareMeshProperty(), ReporterTransferInterface::declareVectorClone(), FunctorRelationshipManager::delete_remote_elements(), MooseMesh::deleteRemoteElements(), MooseApp::determineLibtorchDeviceType(), MeshDiagnosticsGenerator::diagnosticsLog(), Function::div(), FunctorBinnedValuesDivision::divisionIndex(), FunctorRelationshipManager::dofmap_reinit(), MooseApp::dynamicAllRegistration(), MooseApp::dynamicAppRegistration(), DistributedRectilinearMeshGenerator::elemId(), MooseApp::errorCheck(), MooseMesh::errorIfDistributedMesh(), MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp(), FixedPointSolve::examineFixedPointConvergence(), Eigenvalue::execute(), TransientBase::execute(), WebServerControl::execute(), MooseApp::executeExecutioner(), FVInterfaceKernel::faceArg1(), FVInterfaceKernel::faceArg2(), MultiApp::fillPositions(), MooseApp::finalizeRestore(), Transfer::find_sys(), DiracKernelInfo::findPoint(), FixedPointSolve::findTransformedSystem(), FixedPointSolve::FixedPointSolve(), FunctionDT::FunctionDT(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), LinearFVBoundaryCondition::functorFaceArg(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), AdvancedExtruderGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), CoarsenBlockGenerator::generate(), CombinerGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), DistributedRectilinearMeshGenerator::generate(), ElementOrderConversionGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), MeshCollectionGenerator::generate(), MeshDiagnosticsGenerator::generate(), MeshExtruderGenerator::generate(), MeshRepairGenerator::generate(), MoveNodeGenerator::generate(), PlaneIDMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), SmoothMeshGenerator::generate(), SpiralAnnularMeshGenerator::generate(), StackGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainPerElementGenerator::generate(), TiledMeshGenerator::generate(), XYMeshLineCutter::generate(), XYZDelaunayGenerator::generate(), PatternedMeshGenerator::generate(), MeshGenerator::generateCSG(), MeshGenerator::generateData(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), CircularBoundaryCorrectionGenerator::generateRadialCorrectionFactor(), MooseMesh::getAxisymmetricRadialCoord(), MooseMesh::getBlockConnectedBlocks(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), ChainControl::getChainControlDataByName(), WebServerControl::getClientInfo(), MooseMesh::getCoarseningMap(), MultiApp::getCommandLineArgs(), MooseVariableBase::getContinuity(), Control::getControllableParameterByName(), MooseMesh::getCoordSystem(), PhysicsBase::getCoupledPhysics(), PhysicsBase::getCoupledPhysics(), DataFileInterface::getDataFilePath(), TransfiniteMeshGenerator::getDiscreteEdge(), MooseVariableBase::getDofIndices(), VariableCondensationPreconditioner::getDofToCondense(), TransfiniteMeshGenerator::getEdge(), EigenExecutionerBase::getEigenSystemConvergence(), MooseMesh::getElementIDIndex(), Material::getElementIDNeighbor(), Material::getElementIDNeighborByName(), MooseMesh::getElemIDMapping(), MooseMesh::getElemIDsOnBlocks(), WebServerControl::Response::getError(), MultiApp::getExecutioner(), MooseApp::getExecutor(), MultiAppTransfer::getFromMultiApp(), MultiAppTransfer::getFromMultiAppInfo(), getFunctor(), MooseMesh::getGeneralAxisymmetricCoordAxis(), MaterialPropertyInterface::getGenericMaterialPropertyByName(), DistributedRectilinearMeshGenerator::getGhostNeighbors(), DistributedRectilinearMeshGenerator::getIndices(), MaterialPropertyInterface::getKokkosBlockMaterialProperty(), FunctionInterface::getKokkosFunctionByName(), MaterialPropertyInterface::getKokkosMaterialPropertyByName(), Material::getMaterialByName(), getMatrixTagID(), AnnularMesh::getMaxInDimension(), GeneratedMesh::getMaxInDimension(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), AnnularMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MultiAppTransfer::getMultiApp(), DistributedRectilinearMeshGenerator::getNeighbors(), MooseMesh::getNodeBlockIds(), MooseMesh::getNodeList(), MooseMesh::getPairedBoundaryMapping(), MaterialOutputAction::getParams(), PlaneIDMeshGenerator::getPlaneID(), PostprocessorInterface::getPostprocessorValueByNameInternal(), ComponentMaterialPropertyInterface::getPropertyValue(), MooseMesh::getRefinementMap(), MooseBase::getRenamedParam(), ReporterInterface::getReporterContextBaseByName(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), MooseApp::getRMClone(), MooseObject::getSharedPtr(), MooseObject::getSharedPtr(), PhysicsBase::getSolverSystem(), MooseMesh::getSubdomainBoundaryIds(), TransientBase::getTimeIntegratorNames(), MultiAppTransfer::getToMultiApp(), MultiAppTransfer::getToMultiAppInfo(), MooseMesh::getUniqueCoordSystem(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectName(), getVariableHelper(), AddPeriodicBCAction::getVariables(), VectorPostprocessorInterface::getVectorPostprocessorName(), getVectorTag(), getVectorTagID(), MultiApp::globalAppToLocal(), Function::gradient(), MooseVariableBase::hasDoFsOnNodes(), PostprocessorInterface::hasPostprocessor(), PostprocessorInterface::hasPostprocessorByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), TransientBase::incrementStepOrReject(), NEML2Action::inferMOOSEIOType(), AddVariableAction::init(), MooseMesh::init(), Sampler::init(), EigenExecutionerBase::init(), TransientBase::init(), MFEMMesh::init(), CrankNicolson::init(), ExplicitTimeIntegrator::init(), FixedPointIterationAdaptiveDT::init(), IterationAdaptiveDT::init(), MultiApp::init(), NestedDivision::initialize(), ParsedConvergence::initializeConstantSymbol(), PhysicsBase::initializePhysics(), initialSetup(), AuxKernelBase::initialSetup(), SolutionScalarAux::initialSetup(), FullSolveMultiApp::initialSetup(), ExplicitTimeIntegrator::initialSetup(), Function::integral(), InternalSideIndicatorBase::InternalSideIndicatorBase(), EigenExecutionerBase::inversePowerIteration(), Sampler::isAdaptiveSamplingCompleted(), MooseMesh::isBoundaryFullyExternalToSubdomains(), MooseVariableBase::isNodal(), IterationAdaptiveDT::IterationAdaptiveDT(), IterationCountConvergence::IterationCountConvergence(), LibmeshPartitioner::LibmeshPartitioner(), MooseApp::libNameToAppName(), LineSearch::lineSearch(), LibtorchNeuralNetControl::loadControlNeuralNetFromFile(), MooseApp::loadLibraryAndDependencies(), ReporterPointMarker::markerSetup(), Material::Material(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshRepairGenerator::MeshRepairGenerator(), SetupMeshAction::modifyParamsForUseSplit(), MooseApp::MooseApp(), MeshMetaDataInterface::mooseErrorInternal(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableBase::MooseVariableBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppTransfer::MultiAppTransfer(), NewmarkBeta::NewmarkBeta(), DistributedRectilinearMeshGenerator::nodeId(), DistributedRectilinearMeshGenerator::numNeighbors(), Output::onInterval(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), ActionComponent::outerSurfaceArea(), ActionComponent::outerSurfaceBoundaries(), MortarNodalGeometryOutput::output(), Output::Output(), MooseApp::outputMachineReadableData(), DistributedRectilinearMeshGenerator::paritionSquarely(), ParsedConvergence::ParsedConvergence(), ParsedCurveGenerator::ParsedCurveGenerator(), ExplicitTimeIntegrator::performExplicitSolve(), PetscExternalPartitioner::PetscExternalPartitioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularInterface::PiecewiseTabularInterface(), CutMeshByLevelSetGeneratorBase::pointPairLevelSetInterception(), ProjectSideSetOntoLevelSetGenerator::pointPairLevelSetInterception(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName(), AStableDirk4::postResidual(), ExplicitRK2::postResidual(), ExplicitTVDRK2::postResidual(), ImplicitMidpoint::postResidual(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), LStableDirk4::postResidual(), VariableCondensationPreconditioner::preallocateCondensedJacobian(), Predictor::Predictor(), TransientBase::preExecute(), MooseMesh::prepare(), MooseMesh::prepared(), FixedPointSolve::printFixedPointConvergenceReason(), MFEMFunctorMaterial::processLiterals(), MultiApp::readCommandLineArguments(), CoarsenBlockGenerator::recursiveCoarsen(), MooseApp::recursivelyCreateExecutors(), FunctorRelationshipManager::redistribute(), MooseApp::registerRestartableData(), MooseApp::registerRestartableNameWithFilter(), Sampler::reinit(), MooseApp::removeRelationshipManager(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::restore(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), MooseApp::run(), MooseApp::runInputs(), ScalarComponentIC::ScalarComponentIC(), DistributedRectilinearMeshGenerator::scaleNodalPositions(), FunctorRelationshipManager::set_mesh(), MooseVariableBase::setActiveTags(), DistributedRectilinearMeshGenerator::setBoundaryNames(), MooseMesh::setCoordSystem(), MooseMesh::setGeneralAxisymmetricCoordAxes(), MeshGenerator::setMeshProperty(), MooseApp::setMFEMDevice(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Split::setup(), TransientMultiApp::setupApp(), Moose::PeriodicBCHelper::setupAutoPeriodicBoundaries(), Moose::PeriodicBCHelper::setupManualPeriodicBoundaries(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), PhysicsBase::shouldCreateVariable(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), MooseVariableBase::sizeMatrixTagData(), SmoothMeshGenerator::SmoothMeshGenerator(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), Moose::MFEM::LinearSolverBase::Solve(), TimeIntegrator::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), FullSolveMultiApp::solveStep(), UserObject::spatialPoints(), UserObject::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), MeshRepairGenerator::splitNonConvexPolygons(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), MaterialBase::subdomainSetup(), CutMeshByLevelSetGeneratorBase::tet4ElemCutter(), Action::timedAct(), Function::timeDerivative(), Function::timeIntegral(), ParsedCurveGenerator::tSectionSpaceDefiner(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), MooseVariableScalar::uDotOld(), MooseBase::uniqueName(), AuxScalarKernel::uOld(), ScalarKernelBase::uOld(), Function::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), AddVariableAction::variableType(), vectorTagName(), vectorTagType(), Function::vectorValue(), verifyVectorTags(), ActionComponent::volume(), WebServerControl::WebServerControl(), WebServerControl::writePortFile(), MFEMMesh::writeRecoveryFiles(), and MooseApp::writeRestartableMetaData().

mooseErrorNonPrefixed()

template<typename... Args>

void MooseBase::mooseErrorNonPrefixed ( Args &&...  args ) const

inlineinherited

Emits an error without the prefixing included in mooseError().

Definition at line 290 of file MooseBase.h.

  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ false);
  }

mooseInfo()

template<typename... Args>

void MooseBase::mooseInfo ( Args &&...  args ) const

inlineinherited

Definition at line 334 of file MooseBase.h.

  {
    moose::internal::mooseInfoStream(_console, messagePrefix(true), std::forward<Args>(args)...);
  }

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), PIDTransientControl::execute(), Executioner::Executioner(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), FixedPointSolve::findTransformedSystem(), ManifoldSubdomainGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), DataFileInterface::getDataFilePath(), ImplicitMidpoint::ImplicitMidpoint(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), MultiAppTransfer::mapBackWithoutCollapsing(), SolutionInvalidityOutput::output(), MooseBase::paramInfo(), MooseApp::setupOptions(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

mooseWarning() [1/2]

template<typename... Args>

void MooseBase::mooseWarning ( Args &&...  args ) const

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

  {
    moose::internal::mooseWarningStream(_console, messagePrefix(true), std::forward<Args>(args)...);
  }

Referenced by DiracKernelInfo::findPoint(), DataFileInterface::getDataFilePath(), MooseApp::loadLibraryAndDependencies(), MooseBase::paramWarning(), and MooseApp::setupOptions().

mooseWarning() [2/2]

template<typename... Args>

void SolutionInvalidInterface::mooseWarning ( Args &&...  args ) const

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseWarning(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
  }

Referenced by CopyMeshPartitioner::_do_partition(), AddFunctionAction::act(), AddKernelAction::act(), CommonOutputAction::act(), MaterialOutputAction::act(), MeshOnlyAction::act(), MooseMesh::addPeriodicVariable(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkPolygons(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), MultiApp::createApp(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), Postprocessor::evaluateDotWarning(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), BSplineCurveGenerator::generate(), RenumberBySubdomainGenerator::generate(), SubdomainPerElementGenerator::generate(), SurfaceMeshGeneratorBase::get2DElemNormal(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), IndicatorMarker::IndicatorMarker(), CartesianGridDivision::initialize(), CylindricalGridDivision::initialize(), SphericalGridDivision::initialize(), MaterialBase::initStatefulProperties(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MFEMRefinementMarker::MFEMRefinementMarker(), NewmarkBeta::NewmarkBeta(), Output::Output(), MaterialOutputAction::outputHelper(), Executioner::problem(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), MooseMesh::setCoordSystem(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

mooseWarningNonPrefixed() [1/2]

template<typename... Args>

void MooseBase::mooseWarningNonPrefixed ( Args &&...  args ) const

inlineinherited

Emits a warning without the prefixing included in mooseWarning().

Definition at line 308 of file MooseBase.h.

  {
    moose::internal::mooseWarningStream(_console, std::forward<Args>(args)...);
  }

mooseWarningNonPrefixed() [2/2]

template<typename... Args>

void SolutionInvalidInterface::mooseWarningNonPrefixed ( Args &&...  args ) const

inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseWarningNonPrefixed(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
  }

name()

const std::string & MooseBase::name ( ) const

inlineinherited

Get the name of the class.

Returns

The name of the class

Definition at line 103 of file MooseBase.h.

  {
    mooseAssert(_name.size(), "Empty name");
    return _name;
  }

Referenced by AdaptivityAction::act(), AddActionComponentAction::act(), AddElementalFieldAction::act(), AddPeriodicBCAction::act(), AddTimeStepperAction::act(), CommonOutputAction::act(), CopyNodalVarsAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), DisplayGhostingAction::act(), MaterialOutputAction::act(), SetupResidualDebugAction::act(), SetupTimeIntegratorAction::act(), FEProblemBase::addAnyRedistributers(), Executioner::addAttributeReporter(), FEProblemBase::addAuxKernel(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), FEProblemBase::addBoundaryCondition(), MFEMProblem::addBoundaryCondition(), MFEMComplexWeakForm::addBoundaryCondition(), MFEMWeakForm::addBoundaryCondition(), PhysicsComponentInterface::addComponent(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), MFEMProblem::addDefaultProblemComposer(), MFEMProblem::addDefaultWeakForm(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFESpace(), MFEMProblem::addFESpaceHierarchy(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), addFunctor(), FEProblemBase::addFunctorMaterial(), MFEMProblem::addFunctorMaterial(), FunctorMaterial::addFunctorProperty(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblemBase::addFVBC(), FEProblemBase::addFVGradientMethod(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVInterpolationMethod(), FEProblemBase::addFVKernel(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), FEProblemBase::addIndicator(), MFEMProblem::addIndicator(), FEProblemBase::addInitialCondition(), MFEMProblem::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), ElementAndTraceScalarHDGAssemblyHelper::additionalROVariables(), BoundaryIntegralValueConstraint::additionalROVariables(), DiffusionLHDGKernel::additionalROVariables(), ADKernelScalarBase::additionalROVariables(), FEProblemBase::addKernel(), MFEMProblem::addKernel(), MFEMComplexWeakForm::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblemBase::addMarker(), MFEMProblem::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), ComponentMaterialPropertyInterface::addMaterials(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), MFEMProblem::addObject(), FEProblemBase::addObject(), InitialConditionWarehouse::addObject(), ComponentPhysicsInterface::addPhysics(), addPiecewiseByBlockLambdaFunctor(), FEProblemBase::addPostprocessor(), MFEMProblem::addPostprocessor(), UserObjectBase::addPostprocessorDependencyHelper(), AuxKernelBase::addPostprocessorDependencyHelper(), InitialConditionBase::addPostprocessorDependencyHelper(), FEProblemBase::addPredictor(), MFEMProblem::addProblemComposer(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), AddActionComponentAction::addRelationshipManagers(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), WebServerControl::addServerActionsInternal(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), MFEMProblem::addTransfer(), PhysicsBase::addUserObject(), FEProblemBase::addUserObject(), UserObjectBase::addUserObjectDependencyHelper(), AuxKernelBase::addUserObjectDependencyHelper(), InitialConditionBase::addUserObjectDependencyHelper(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), MFEMProblem::addVectorPostprocessor(), UserObjectBase::addVectorPostprocessorDependencyHelper(), AuxKernelBase::addVectorPostprocessorDependencyHelper(), MFEMProblem::addWeakForm(), MooseLinearVariableFV< OutputType >::adError(), Output::advancedExecuteOn(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), NEML2ModelExecutor::advanceState(), MooseVariableBase::allDofIndices(), MooseApp::appBinaryName(), MooseApp::appendMeshGenerator(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayDGKernel::ArrayDGKernel(), ArrayParsedAux::ArrayParsedAux(), PhysicsBase::assignBlocks(), AStableDirk4::AStableDirk4(), Function::average(), MultiApp::backup(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), PiecewiseTabularInterface::buildFromFile(), PiecewiseTabularInterface::buildFromXY(), MFEMGeometricMultigridSolver::BuildMultigrid(), MooseMesh::buildNodeListFromSideList(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MooseBase::callMooseError(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), PhysicsBase::checkBlockRestrictionIdentical(), PhysicsBase::checkComponentType(), DefaultNonlinearConvergence::checkConvergence(), ParsedConvergence::checkConvergence(), checkCoupledScalarVariableBlocks(), FEProblemBase::checkDependMaterialsHelper(), FVFluxBC::checkFaceIntegrity(), FVInterfaceKernel::checkFaceIntegrity(), TaggingInterface::checkForNans(), SamplerBase::checkForStandardFieldVariableType(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), NonlinearSystemBase::checkKernelCoverage(), Moose::Kokkos::Material::checkMaterialProperty(), Material::checkMaterialProperty(), MooseApp::checkMetaDataIntegrity(), Damper::checkMinDamping(), SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), Checkpoint::checkpointInfo(), LinearFVGradientManager::checkRestartedGradientHistory(), FEProblemBase::checkUserObjectNameCollision(), BlockRestrictable::checkVariable(), DomainUserObject::checkVariable(), Coupleable::checkWritableVar(), CoarsenSurfaceMeshAlongSidesetGenerator::coarsenAlongSidesets(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), MaterialBase::computeProperties(), FEProblemBase::computeUserObjectByName(), VectorPostprocessorVisualizationAux::computeValue(), MooseBase::connectControllableParams(), ConstantPostprocessor::ConstantPostprocessor(), Coupleable::coupledName(), CommonOutputAction::create(), MultiApp::createApp(), MooseApp::createExecutors(), MeshGeneratorSystem::createMeshGeneratorOrder(), MooseApp::createRecoverablePerfGraph(), MoveBoundaryNodesToCurveGenerator::curveGenerator(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), DebugResidualAux::DebugResidualAux(), MaterialBase::declareADProperty(), MFEMComplexVariable::declareCoefficients(), MFEMVariable::declareCoefficients(), MeshInfo::declareHelper(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MeshGenerator::declareMeshesForSubByName(), MeshGenerator::declareNullMeshName(), MaterialBase::declareProperty(), MFEMCoordinateTransformations::declareRZCoefficients(), DOFMapOutput::demangle(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), MooseMesh::detectPairedSidesets(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DomainUserObject::DomainUserObject(), DumpObjectsProblem::dumpObjectHelper(), ElementDamper::ElementDamper(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementMaterialSampler::ElementMaterialSampler(), ElementValueSampler::ElementValueSampler(), EigenKernel::enabled(), MooseMesh::errorIfDistributedMesh(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), RestartableDataReporter::execute(), MultiAppGeneralFieldTransfer::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppUserObjectTransfer::execute(), SideValueSampler::execute(), WebServerControl::execute(), ActionWarehouse::executeActionsWithAction(), Exodus::Exodus(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FVInterfaceKernel::faceArg1(), FVInterfaceKernel::faceArg2(), FEProblemBase::FEProblemBase(), NEML2ModelExecutor::fillInputs(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), PointSamplerBase::finalize(), ChainControl::fullControlDataName(), FunctionArrayAux::FunctionArrayAux(), FunctionDT::FunctionDT(), FVFunctionIC::functionName(), FunctionIC::functionName(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), GapValueAux::GapValueAux(), BoundaryDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenSurfaceMeshAlongSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), ManifoldSubdomainGenerator::generate(), ParsedExtraElementIDGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), StitchBoundaryMeshGenerator::generate(), StitchMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), InterfaceMaterial::getADMaterialProperty(), Material::getADMaterialProperty(), MultiAppTransfer::getAppInfo(), MooseMesh::getBoundaryString(), MultiApp::getBoundingBox(), MooseBase::getCheckedPointerParam(), MooseApp::getCheckpointDirectories(), MFEMProblem::getComplexGridFunction(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), FEProblemBase::getConvergence(), MeshGenerator::getCSGBase(), MeshGenerator::getCSGBasesByName(), UserObjectBase::getDependObjects(), FEProblemBase::getDistribution(), DistributionInterface::getDistribution(), DistributionInterface::getDistributionByName(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), MultiApp::getExecutioner(), FEProblemBase::getExecutor(), MooseApp::getExecutor(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), getFunctor(), FEProblemBase::getFVAdvectedInterpolationMethod(), FEProblemBase::getFVFaceInterpolationMethod(), FEProblemBase::getFVGradientMethod(), FEProblemBase::getFVGradientMethod(), FEProblemBase::getFVInterpolationMethod(), AuxKernelTempl< ComputeValueType >::getGenericMaterialProperty(), NodalPatchRecovery::getGenericMaterialProperty(), InterfaceMaterial::getGenericMaterialProperty(), Material::getGenericMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialPropertyByName(), Material::getGenericOptionalMaterialProperty(), MaterialBase::getGenericZeroMaterialProperty(), MFEMProblem::getGridFunction(), FEProblemBase::getKokkosFunction(), FEProblemBase::getKokkosUserObject(), SolutionUserObjectBase::getLocalVarIndex(), Marker::getMarkerValue(), Material::getMaterial(), FEProblemBase::getMaterial(), Material::getMaterialByName(), AuxKernelTempl< ComputeValueType >::getMaterialProperty(), NodalPatchRecovery::getMaterialProperty(), InterfaceMaterial::getMaterialProperty(), Material::getMaterialProperty(), getMaterialPropertyBlockNames(), getMaterialPropertyBoundaryNames(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOld(), InterfaceMaterial::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), AuxKernelTempl< ComputeValueType >::getMaterialPropertyOlder(), NodalPatchRecovery::getMaterialPropertyOlder(), InterfaceMaterial::getMaterialPropertyOlder(), Material::getMaterialPropertyOlder(), MFEMObject::getMatrixCoefficient(), MFEMObject::getMatrixCoefficientByName(), MeshGenerator::getMesh(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshesByName(), MooseApp::getMeshGenerator(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MFEMProblem::getMFEMObject(), ActionWarehouse::getMooseAppName(), NEML2FEInterpolation::getMOOSEVariable(), MultiAppTransfer::getMultiApp(), InterfaceMaterial::getNeighborADMaterialProperty(), InterfaceMaterial::getNeighborMaterialProperty(), InterfaceMaterial::getNeighborMaterialPropertyOld(), InterfaceMaterial::getNeighborMaterialPropertyOlder(), Material::getOptionalADMaterialProperty(), Material::getOptionalMaterialProperty(), Material::getOptionalMaterialPropertyOld(), Material::getOptionalMaterialPropertyOlder(), MooseBase::getParam(), FEProblemBase::getPositionsObject(), FEProblemBase::getPostprocessorValueByName(), ComponentMaterialPropertyInterface::getPropertyValue(), ReporterData::getReporterInfo(), MFEMExecutedObject::getRequestedItems(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), FEProblemBase::getSampler(), MFEMObject::getScalarCoefficient(), MFEMObject::getScalarCoefficientByName(), TimedSubdomainModifier::getSubdomainIDAndCheck(), MFEMExecutedObject::getSuppliedItems(), TransientBase::getTimeStepperName(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), MFEMObject::getVectorCoefficient(), MFEMObject::getVectorCoefficientByName(), LinearFVGradientManager::gradientStateVectorName(), Terminator::handleMessage(), Control::hasControllableParameterByName(), FEProblemBase::hasConvergence(), FEProblemBase::hasDistribution(), FEProblemBase::hasFunction(), hasFunctor(), hasFunctorWithType(), FEProblemBase::hasFVGradientMethod(), FEProblemBase::hasFVInterpolationMethod(), MeshInfo::hasItem(), MooseApp::hasMeshGenerator(), MFEMProblem::hasMFEMObject(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasPostprocessorValueByName(), MooseApp::hasRelationshipManager(), MooseApp::hasRestartableDataMap(), MooseApp::hasRestartableMetaData(), FEProblemBase::hasUserObject(), NEML2Action::inferMOOSEIOType(), AddVariableAction::init(), AdvancedOutput::init(), IterationAdaptiveDT::init(), AdvancedOutput::initAvailableLists(), MeshInfo::initCombinedInfos(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), NestedDivision::initialize(), TransformedPositions::initialize(), BoundaryRestrictable::initializeBoundaryRestrictable(), AuxKernelBase::initialSetup(), SolutionScalarAux::initialSetup(), MFEMScalarQuadratureFunction::initialSetup(), MFEMVectorQuadratureFunction::initialSetup(), Console::initialSetup(), JSONOutput::initialSetup(), BoundaryLinearFVFluxIntegral::initialSetup(), NodalVariableValue::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppGeneralFieldFunctorTransfer::initialSetup(), MultiAppProjectionTransfer::initialSetup(), BoundaryMeshBuilder::initialSetup(), SolutionUserObjectBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), MeshGenerator::isChildMeshGenerator(), DerivativeMaterialInterface< T >::isNotObjectVariable(), MeshGenerator::isNullMeshName(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MeshGenerator::isParentMeshGenerator(), LinearCombinationFunction::LinearCombinationFunction(), FEProblemBase::logAdd(), MooseLinearVariableFV< OutputType >::lowerDError(), Marker::Marker(), MaterialBase::markMatPropRequested(), Material::Material(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), NEML2ModelExecutor::meshChanged(), MeshGenerator::meshPropertyPrefix(), MooseBase::messagePrefix(), MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver(), MFEMScalarQuadratureFunction::MFEMScalarQuadratureFunction(), MFEMVectorQuadratureFunction::MFEMVectorQuadratureFunction(), MooseApp::MooseApp(), OutputWarehouse::mooseConsole(), SolutionInvalidInterface::mooseDeprecated(), MooseVariableBase::MooseVariableBase(), MooseVariableInterface< T >::MooseVariableInterface(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NEML2PreKernel::NEML2PreKernel(), NodalDamper::NodalDamper(), MooseLinearVariableFV< OutputType >::nodalError(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalValueSampler::NodalValueSampler(), MeshGenerator::Comparator::operator()(), DOFMapOutput::output(), ProgressOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), ConsoleUtils::outputExecutionInformation(), MaterialOutputAction::outputHelper(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), Exodus::outputPostprocessors(), Nemesis::outputPostprocessors(), TableOutput::outputReporter(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), SolutionInvalidInterface::paramWarning(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), ComponentPhysicsInterface::physicsExists(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseFunction::PiecewiseFunction(), PointInUnionCheckUO::PointInUnionCheckUO(), MooseApp::possiblyLoadRestartableMetaData(), MFEMExecutedObject::postprocessorDependencyKey(), PhysicsBase::prefix(), MooseMesh::prepare(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), PerfGraphLivePrint::printStats(), FEProblemBase::projectInitialConditionOnCustomRange(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), Receiver::Receiver(), Executor::Result::record(), FEProblemBase::registerRandomInterface(), MooseApp::registerRestartableDataMapName(), MooseApp::registerRestartableNameWithFilter(), MaterialBase::resetQpProperties(), MultiApp::restore(), ScalarComponentIC::ScalarComponentIC(), MultiApp::setAppOutputFileBase(), FEProblemBase::setAuxKernelParamsAndLog(), MooseMesh::setBoundaryName(), Control::setControllableValue(), Control::setControllableValueByName(), OutputWarehouse::setFileNumbers(), FEProblemBase::setPostprocessorValueByName(), FEProblemBase::setResidualObjectParamsAndLog(), MooseMesh::setSubdomainName(), MooseMesh::setSubdomainName(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), Split::setup(), TransientMultiApp::setupApp(), MoveNodesByParsedExpressionModifier::setupNodalOutputVariables(), NEML2Action::setupOutputMappings(), SideSetExtruderGenerator::SideSetExtruderGenerator(), TransientMultiApp::solveStep(), UserObject::spatialValue(), LinearFVGradientReader::stateComponents(), StitchedMesh::StitchedMesh(), storeBoundaryDelayedCheckMatProp(), storeBoundaryMatPropName(), MaterialBase::storeBoundaryZeroMatProp(), storeBoundaryZeroMatProp(), storeSubdomainDelayedCheckMatProp(), storeSubdomainMatPropName(), MaterialBase::storeSubdomainZeroMatProp(), storeSubdomainZeroMatProp(), ConstraintWarehouse::subdomainsCovered(), MaterialBase::subdomainSetup(), SumPostprocessor::SumPostprocessor(), MFEMPostprocessor::suppliedPostprocessorName(), MFEMVectorPostprocessor::suppliedVectorPostprocessorName(), BoundaryMeshBuilder::surfaceElementSet(), NEML2FEInterpolation::syncWithMainThread(), TaggingInterface::TaggingInterface(), MooseLinearVariableFV< OutputType >::timeIntegratorError(), VectorPostprocessorVisualizationAux::timestepSetup(), ElementSubdomainModifierBase::timestepSetup(), to_json(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), MultiAppMFEMCopyTransfer::transferVariables(), MultiAppMFEMShapeEvaluationTransfer::transferVariables(), TransientMultiApp::TransientMultiApp(), MooseBase::typeAndName(), MooseBase::uniqueParameterName(), FVQpFluxBC::uOnGhost(), FVQpFluxBC::uOnUSub(), UserObjectBase::UserObjectBase(), UserObjectInterface::userObjectName(), ParsedAux::validateGenericVectorNames(), MeshInfo::validParams(), MFEMExecutedObject::variableDependencyKey(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), MFEMExecutedObject::vectorPostprocessorDependencyKey(), Convergence::verboseOutput(), AdvancedOutput::wantOutput(), Coupleable::writableCoupledValue(), Coupleable::writableVariable(), Console::write(), MooseApp::writeRestartableMetaData(), and XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve().

needFV()

virtual void SubProblem::needFV ( )

pure virtual

marks this problem as including/needing finite volume functionality.

Implemented in DisplacedProblem, and FEProblemBase.

nlConverged()

bool SubProblem::nlConverged ( const unsigned int  nl_sys_num )

virtual

Returns

whether the given nonlinear system nl_sys_num is converged.

Definition at line 708 of file SubProblem.C.

{
  mooseAssert(nl_sys_num < numNonlinearSystems(),
              "The nonlinear system number is higher than the number of systems we have!");
  return solverSystemConverged(nl_sys_num);
}

nLinearIterations()

unsigned int SubProblem::nLinearIterations ( const unsigned int  nl_sys_num ) const

virtual

Reimplemented in FEProblemBase.

Definition at line 758 of file SubProblem.C.

{
  return 0;
}

Referenced by IterationInfo::execute(), and NumLinearIterations::getValue().

nlSysNum()

virtual unsigned int SubProblem::nlSysNum ( const NonlinearSystemName &  nl_sys_name ) const

pure virtual

Returns

the nonlinear system number corresponding to the provided nl_sys_name

Implemented in DisplacedProblem, and FEProblemBase.

nNonlinearIterations()

unsigned int SubProblem::nNonlinearIterations ( const unsigned int  nl_sys_num ) const

virtual

Reimplemented in FEProblemBase.

Definition at line 752 of file SubProblem.C.

{
  return 0;
}

Referenced by IterationInfo::execute(), and NumNonlinearIterations::finalize().

nonlocalCouplingMatrix()

virtual const libMesh::CouplingMatrix & SubProblem::nonlocalCouplingMatrix ( const unsigned  i ) const

pure virtual

Returns

the nonlocal coupling matrix for the i'th nonlinear system

Implemented in DisplacedProblem, and FEProblemBase.

numLinearSystems()

virtual std::size_t SubProblem::numLinearSystems ( ) const

pure virtual

Returns

the number of linear systems in the problem

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by hasLinearVariable().

numMatrixTags()

virtual unsigned int SubProblem::numMatrixTags ( ) const

inlinevirtual

The total number of tags.

Reimplemented in DisplacedProblem.

Definition at line 251 of file SubProblem.h.

{ return _matrix_tag_name_to_tag_id.size(); }

Referenced by SystemBase::activateAllMatrixTags(), NonlinearSystemBase::computeNodalBCsJacobian(), NonlinearSystemBase::computeScalarKernelsJacobians(), SystemBase::deactivateAllMatrixTags(), ComputeJacobianThread::determineObjectWarehouses(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), DisplacedProblem::numMatrixTags(), ComputeNodalKernelBCJacobiansThread::pre(), ComputeNodalKernelJacobiansThread::pre(), MooseVariableScalar::sizeMatrixTagData(), and ComputeDiracThread::subdomainChanged().

numNonlinearSystems()

virtual std::size_t SubProblem::numNonlinearSystems ( ) const

pure virtual

Returns

the number of nonlinear systems in the problem

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by addCouplingGhostingFunctor(), automaticScaling(), clearAllDofIndices(), cloneCouplingGhostingFunctor(), nlConverged(), preparePRefinement(), reinitElemFaceRef(), reinitFVFace(), reinitLowerDElem(), reinitMortarElem(), reinitNeighborFaceRef(), reinitNeighborLowerDElem(), reinitNodes(), reinitNodesNeighbor(), removeCouplingGhostingFunctor(), setActiveScalarVariableCoupleableVectorTags(), and setCurrentLowerDElem().

numSolverSystems()

virtual std::size_t SubProblem::numSolverSystems ( ) const

pure virtual

Returns

the number of solver systems in the problem

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by setActiveFEVariableCoupleableVectorTags(), and setCurrentBoundaryID().

numThreads()

THREAD_ID SubProblem::numThreads

(

)

const

Returns

the number of threads the associated application uses (see MooseApp::numThreads())

Definition at line 81 of file SubProblem.C.

{ return getMooseApp().numThreads(); }

Referenced by Adaptivity::adaptMesh(), FEProblemBase::addConvergence(), FEProblemBase::addFunction(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterpolationMethod(), FEProblemBase::addIndicator(), FEProblemBase::addInitialCondition(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), FEProblemBase::addObject(), FEProblemBase::addUserObject(), FEProblemBase::bumpAllQRuleOrder(), DisplacedProblem::bumpAllQRuleOrder(), FEProblemBase::bumpVolumeQRuleOrder(), DisplacedProblem::bumpVolumeQRuleOrder(), FEProblemBase::checkNonlocalCoupling(), FEProblemBase::computeBounds(), FEProblemBase::computeIndicators(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeMarkers(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::computeUserObjectsInternal(), FEProblemBase::createQRules(), DisplacedProblem::createQRules(), FEProblemBase::customSetup(), PenetrationLocator::detectPenetration(), DisplacedProblem::DisplacedProblem(), FEProblemBase::executeSamplers(), FEProblemBase::FEProblemBase(), NearestNodeLocator::findNodes(), DisplacedProblem::init(), FEProblem::init(), FEProblemBase::init(), FEProblemBase::initElementStatefulProps(), DumpObjectsProblem::initialSetup(), FEProblemBase::initXFEM(), MaterialPropertyStorage::MaterialPropertyStorage(), FEProblemBase::meshChanged(), FEProblemBase::newAssemblyArray(), PenetrationLocator::PenetrationLocator(), preparePRefinement(), FEProblemBase::projectInitialConditionOnCustomRange(), FEProblemBase::projectSolution(), FEProblemBase::reinitDirac(), FixedPointSolve::solve(), TransientMultiApp::solveStep(), SubProblem(), FEProblemBase::timestepSetup(), DisplacedProblem::undisplaceMesh(), FEProblemBase::updateActiveObjects(), Adaptivity::updateErrorVectors(), FEProblemBase::updateMaxQps(), DisplacedProblem::updateMesh(), DisplacedProblem::updateMesh(), NearestNodeLocator::updatePatch(), FEProblemBase::~FEProblemBase(), and PenetrationLocator::~PenetrationLocator().

numVectorTags()

unsigned int SubProblem::numVectorTags ( const Moose::VectorTagType  type = Moose::VECTOR_TAG_ANY ) const

virtual

The total number of tags, which can be limited to the tag type.

Reimplemented in DisplacedProblem.

Definition at line 187 of file SubProblem.C.

{
  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
 
  return getVectorTags(type).size();
}

Referenced by NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeResidualInternal(), ComputeResidualThread::determineObjectWarehouses(), MooseVariableDataBase< OutputType >::MooseVariableDataBase(), MooseVariableScalar::MooseVariableScalar(), DisplacedProblem::numVectorTags(), ComputeNodalKernelBcsThread::pre(), and ComputeNodalKernelsThread::pre().

onTimestepBegin()

virtual void SubProblem::onTimestepBegin ( )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

onTimestepEnd()

virtual void SubProblem::onTimestepEnd ( )

pure virtual

Implemented in DisplacedProblem, DumpObjectsProblem, and FEProblemBase.

paramError()

template<typename... Args>

void MooseBase::paramError ( const std::string &  param, Args...  args  ) const

inherited

Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseError - only printing a message using the given args.

Definition at line 457 of file MooseBase.h.

{
  _pars.paramError(param, std::forward<Args>(args)...);
}

Referenced by HierarchicalGridPartitioner::_do_partition(), AutoCheckpointAction::act(), CommonOutputAction::act(), SetupDebugAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), NEML2ModelExecutor::addGatheredParameter(), NEML2ModelExecutor::addGatheredVariable(), ADDGKernel::ADDGKernel(), ComponentJunction::addMeshGenerators(), CylinderComponent::addMeshGenerators(), ReporterPointSource::addPoints(), DiffusionPhysicsBase::addPostprocessors(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ADPenaltyPeriodicSegmentalConstraint::ADPenaltyPeriodicSegmentalConstraint(), ADPeriodicSegmentalConstraint::ADPeriodicSegmentalConstraint(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), ArrayBodyForce::ArrayBodyForce(), ArrayCoupledForce::ArrayCoupledForce(), ArrayDGKernel::ArrayDGKernel(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayDirichletBC::ArrayDirichletBC(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), ArrayParsedAux::ArrayParsedAux(), ArrayPenaltyDirichletBC::ArrayPenaltyDirichletBC(), ArrayReactionNodalKernelTempl< is_ad >::ArrayReactionNodalKernelTempl(), ArrayVacuumBC::ArrayVacuumBC(), ArrayVarReductionAux::ArrayVarReductionAux(), ParsedSubdomainIDsGenerator::assignElemSubdomainID(), AuxKernelBase::AuxKernelBase(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BlockDeletionGenerator::BlockDeletionGenerator(), BlockWeightedPartitioner::BlockWeightedPartitioner(), BoundaryIntegralValueConstraint::BoundaryIntegralValueConstraint(), BoundaryLinearFVFluxIntegral::BoundaryLinearFVFluxIntegral(), BoundsBase::BoundsBase(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BSplineCurveGenerator::BSplineCurveGenerator(), BuildArrayVariableAux::BuildArrayVariableAux(), MFEMFESpaceHierarchy::buildHierarchy(), MFEMMesh::buildMesh(), MFEMGeometricMultigridSolver::BuildMultigrid(), TimeSequenceStepperBase::buildSequence(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), SurfaceDelaunayGeneratorBase::checkBoundaryAndHolesParams(), checkComponent(), Moose::Kokkos::ParsedObjectBase::checkDuplicateSymbols(), SamplerBase::checkForStandardFieldVariableType(), MeshGenerator::checkGetMesh(), ComponentInitialConditionInterface::checkInitialConditionsAllRequested(), BatchMeshGeneratorAction::checkInputParameterType(), PhysicsBase::checkIntegrityEarly(), SurfaceDelaunayGeneratorBase::checkInteriorPoints(), SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MFEMMultiAppTransfer::checkValidTransferProblemTypes(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), CircularBoundaryCorrectionGenerator::CircularBoundaryCorrectionGenerator(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), CoarsenBlockGenerator::CoarsenBlockGenerator(), CombinedVectorPostprocessor::CombinedVectorPostprocessor(), CombinerGenerator::CombinerGenerator(), ComponentInitialConditionInterface::ComponentInitialConditionInterface(), ComponentJunction::ComponentJunction(), ComponentMaterialPropertyInterface::ComponentMaterialPropertyInterface(), CompositionDT::CompositionDT(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), MFEMNewtonNonlinearSolver::ConstructSolver(), ContainsPointAux::ContainsPointAux(), CopyValueAux::CopyValueAux(), MultiAppGeneralFieldTransfer::correctSolutionVectorValues(), Coupleable::Coupleable(), CoupledForceTempl< is_ad >::CoupledForceTempl(), CoupledValueFunctionMaterialTempl< is_ad >::CoupledValueFunctionMaterialTempl(), MultiApp::createApp(), MeshGeneratorSystem::createMeshGenerator(), MoveBoundaryNodesToCurveGenerator::curveGenerator(), CylindricalGridDivision::CylindricalGridDivision(), DebugResidualAux::DebugResidualAux(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), AccumulateReporter::declareLateValues(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DGLowerDKernel::DGLowerDKernel(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), EigenProblem::EigenProblem(), EigenProblemSolve::EigenProblemSolve(), ElementAdaptivityLevelAux::ElementAdaptivityLevelAux(), ElementGenerator::ElementGenerator(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementLengthAux::ElementLengthAux(), ElementLpNormAux::ElementLpNormAux(), ElementNormalAux::ElementNormalAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), ElementValueSampler::ElementValueSampler(), ElementVectorL2Error::ElementVectorL2Error(), EqualValueEmbeddedConstraintTempl< is_ad >::EqualValueEmbeddedConstraintTempl(), ReporterPointSource::errorCheck(), StitchMeshGeneratorBase::errorMissingBoundary(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), FunctorNodalCorrector::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), ExtraElementIDAux::ExtraElementIDAux(), ExtraElementIntegerDivision::ExtraElementIntegerDivision(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::FileMeshGenerator(), FillBetweenCurvesGenerator::FillBetweenCurvesGenerator(), FillBetweenSidesetsGenerator::FillBetweenSidesetsGenerator(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), InternalSideIndicatorBase::finalize(), MeshTriangulationUtils::finalizeTriangulation(), FixedPointSolve::findTransformedSystem(), FixedPointSolve::FixedPointSolve(), ForcingFunctionAux::ForcingFunctionAux(), FullSolveMultiApp::FullSolveMultiApp(), FunctionArrayAux::FunctionArrayAux(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FunctorADConverterTempl< T >::FunctorADConverterTempl(), FunctorAux::FunctorAux(), FunctorBinnedValuesDivision::FunctorBinnedValuesDivision(), FunctorCoordinatesFunctionAux::FunctorCoordinatesFunctionAux(), FunctorElementalGradientAuxTempl< is_ad >::FunctorElementalGradientAuxTempl(), FunctorExtremaPositions::FunctorExtremaPositions(), FunctorIC::FunctorIC(), FunctorNodalCorrector::FunctorNodalCorrector(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FunctorVectorElementalAuxTempl< is_ad >::FunctorVectorElementalAuxTempl(), FVAdvection::FVAdvection(), FVFluxBC::FVFluxBC(), FVInterfaceKernel::FVInterfaceKernel(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), FVTwoVarContinuityConstraint::FVTwoVarContinuityConstraint(), Boundary2DDelaunayGenerator::General2DDelaunay(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), AddMetaDataGenerator::generate(), AdvancedExtruderGenerator::generate(), BlockDeletionGenerator::generate(), BlockToMeshConverterGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BoundaryDeletionGenerator::generate(), BoundaryElementConversionGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), BreakMeshByBlockGenerator::generate(), BreakMeshByElementGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), CoarsenBlockGenerator::generate(), CoarsenSurfaceMeshAlongSidesetGenerator::generate(), CombinerGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), ElementsToTetrahedronsConverter::generate(), ExtraNodesetGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenSidesetsGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), ManifoldSubdomainGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), MoveBoundaryNodesToCurveGenerator::generate(), ParsedCurveGenerator::generate(), ParsedExtraElementIDGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), PlaneIDMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), ProjectSideSetOntoLevelSetGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), RenumberBySubdomainGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), StackGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), SurfaceSubdomainsDelaunayRemesher::generate(), TriToQuadConverter::generate(), UniqueExtraIDMeshGenerator::generate(), XYFrontalDelaunayGenerator::generate(), XYMeshLineCutter::generate(), XYZDelaunayGenerator::generate(), PatternedMeshGenerator::generate(), GeneratedMeshGenerator::GeneratedMeshGenerator(), BoundaryLayerUtils::generateOffsetPolyline(), GenericConstantStdVectorMaterialTempl< is_ad >::GenericConstantStdVectorMaterialTempl(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), PropertyReadFile::getBlockData(), ComponentBoundaryConditionInterface::getBoundaryCondition(), MultiApp::getCommandLineArgs(), PropertyReadFile::getData(), PropertyReadFile::getFileNames(), Sampler::getGlobalSamples(), ComponentInitialConditionInterface::getInitialCondition(), NEML2Action::getInputParameterMapping(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), Sampler::getLocalSamples(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), FEProblemSolve::getParamFromNonlinearSystemVectorParam(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), Sampler::getSampleRow(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), UserObjectInterface::getUserObjectBase(), UserObjectInterface::getUserObjectName(), AddPeriodicBCAction::getVariables(), HFEMDirichletBC::HFEMDirichletBC(), AddVariableAction::init(), MFEMTransient::init(), MultiApp::init(), MFEMWeakFormBase::initEquationSystem(), DistributedPositions::initialize(), BlockWeightedPartitioner::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), PhysicsBase::initializePhysics(), ReferenceResidualConvergence::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), SolutionIC::initialSetup(), LibtorchControlValuePostprocessor::initialSetup(), ElementSubdomainModifierBase::initialSetup(), MFEMScalarCoefficientPointValueSampler::initialSetup(), FullSolveMultiApp::initialSetup(), JSONOutput::initialSetup(), BoundaryLinearFVFluxIntegral::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), MultiAppGeneralFieldKDTreeTransferBase::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), PointInPolyhedronCheckUO::initialSetup(), HistogramVectorPostprocessor::initialSetup(), SampledOutput::initSample(), AddMetaDataGenerator::inputChecker(), IntegratedBC::IntegratedBC(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceValueUserObjectAux::InterfaceValueUserObjectAux(), InternalSideIndicatorBase::InternalSideIndicatorBase(), InterpolatedStatefulMaterialTempl< T >::InterpolatedStatefulMaterialTempl(), InversePowerMethod::InversePowerMethod(), IterationAdaptiveDT::IterationAdaptiveDT(), MultiApp::keepSolutionDuringRestore(), Kernel::Kernel(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationFunction::LinearCombinationFunction(), LinearFVAdvectionDiffusionFunctorRobinBC::LinearFVAdvectionDiffusionFunctorRobinBC(), Moose::MFEM::LinearSolverBase::LinearSolverBase(), LowerDIntegratedBC::LowerDIntegratedBC(), PNGOutput::makeMeshFunc(), MatCoupledForce::MatCoupledForce(), MaterialADConverterTempl< T >::MaterialADConverterTempl(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MatReactionTempl< is_ad >::MatReactionTempl(), MatrixSymmetryCheck::MatrixSymmetryCheck(), PatternedMeshGenerator::mergeSubdomainNameMaps(), MeshCollectionGenerator::MeshCollectionGenerator(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshDivisionAux::MeshDivisionAux(), MeshGenerator::MeshGenerator(), MeshGeneratorComponent::MeshGeneratorComponent(), MeshInfo::MeshInfo(), MFEMComplexSumAux::MFEMComplexSumAux(), MFEMEigenproblem::MFEMEigenproblem(), MFEMFunctorMaterial::MFEMFunctorMaterial(), MFEMGeneratedMeshGenerator::MFEMGeneratedMeshGenerator(), MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial(), MFEMGenericFunctorMatrixMaterial::MFEMGenericFunctorMatrixMaterial(), MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial(), MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver(), MFEMHypreBoomerAMG::MFEMHypreBoomerAMG(), MFEMMultiAppTransfer::MFEMMultiAppTransfer(), MFEMNDtoRTAux::MFEMNDtoRTAux(), MFEMSumAux::MFEMSumAux(), MFEMVariable::MFEMVariable(), MFEMWeakFormProblemComposerBase::MFEMWeakFormProblemComposerBase(), MooseLinearVariableFV< OutputType >::MooseLinearVariableFV(), UserObjectInterface::mooseObjectError(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveBoundaryNodesToCurveGenerator::MoveBoundaryNodesToCurveGenerator(), MoveNodeGenerator::MoveNodeGenerator(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), TriToQuadConverter::moveSurvivingTriangles(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldKDTreeTransferBase::MultiAppGeneralFieldKDTreeTransferBase(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorToAuxScalarTransfer::MultiAppPostprocessorToAuxScalarTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppProjectionTransfer::MultiAppProjectionTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppScalarToAuxScalarTransfer::MultiAppScalarToAuxScalarTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiAppVectorPostprocessorTransfer::MultiAppVectorPostprocessorTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NearestNodeValueAux::NearestNodeValueAux(), NEML2Action::NEML2Action(), NEML2PreKernel::NEML2PreKernel(), NestedDivision::NestedDivision(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), NodalValueSampler::NodalValueSampler(), NumDOFs::NumDOFs(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), MeshTriangulationUtils::outerBoundaryIds(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), ParsedSubdomainGeneratorBase::ParsedSubdomainGeneratorBase(), ParsedVectorRealReductionReporter::ParsedVectorRealReductionReporter(), ParsedVectorReporter::ParsedVectorReporter(), ParsedVectorVectorRealReductionReporter::ParsedVectorVectorRealReductionReporter(), PatternedMeshGenerator::PatternedMeshGenerator(), PenaltyPeriodicSegmentalConstraint::PenaltyPeriodicSegmentalConstraint(), PeriodicSegmentalConstraint::PeriodicSegmentalConstraint(), PIDTransientControl::PIDTransientControl(), PlaneDeletionGenerator::PlaneDeletionGenerator(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), PointInPolyhedronBaseUO::PointInPolyhedronBaseUO(), PointInSignedFunctionCheckUO::PointInSignedFunctionCheckUO(), PointInUnionCheckUO::PointInUnionCheckUO(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), EqualValueBoundaryConstraint::populateSecondaryNodes(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), LibmeshPartitioner::prepareBlocksForSubdomainPartitioner(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectSideSetOntoLevelSetGenerator::ProjectSideSetOntoLevelSetGenerator(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), RankTwoTensorFromComponentProperties::RankTwoTensorFromComponentProperties(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusIIOrNemesis(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), RefineBlockGenerator::RefineBlockGenerator(), RefineSidesetGenerator::RefineSidesetGenerator(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), ReporterPointSource::ReporterPointSource(), FEProblemBase::restoreSolutions(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), FEProblemBase::setLinearConvergenceNames(), FEProblemBase::setNonlinearConvergenceNames(), MooseMesh::setPartitioner(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), Moose::MFEM::LinearSolverBase::SetPreconditionerImpl(), MFEMHypreAME::SetPreconditionerImpl(), MFEMHypreFGMRES::SetPreconditionerImpl(), MFEMHypreGMRES::SetPreconditionerImpl(), MFEMHyprePCG::SetPreconditionerImpl(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), SurfaceMeshGeneratorBase::setup(), CylinderComponent::setupComponent(), NEML2Action::setupDerivativeMappings(), NEML2Action::setupInputMappings(), MultiSystemSolveObject::setupMultiSystemFixedPointRelaxationFactors(), MoveNodesByParsedExpressionModifier::setupNodalOutputVariables(), NEML2Action::setupParameterDerivativeMappings(), NEML2Action::setupParameterMappings(), SetupQuadratureAction::SetupQuadratureAction(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideValueSampler::SideValueSampler(), SingleRankPartitioner::SingleRankPartitioner(), SphericalGridDivision::SphericalGridDivision(), StitchBoundaryMeshGenerator::StitchBoundaryMeshGenerator(), StitchMeshGenerator::StitchMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TagVectorAux::TagVectorAux(), XYFrontalDelaunayGenerator::targetArea(), Terminator::Terminator(), TimeDerivativeAux::TimeDerivativeAux(), Transfer::Transfer(), TransformGenerator::TransformGenerator(), TransientMultiApp::TransientMultiApp(), CylinderComponent::translation(), MeshTriangulationUtils::triangulateWithDelaunay(), TriToQuadConverter::TriToQuadConverter(), ParsedCurveGenerator::tSectionSpaceDefiner(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), UserObjectBase::UserObjectBase(), Checkpoint::validateExecuteOn(), ParsedAux::validateGenericVectorNames(), SolutionAux::validateVariable(), MFEMProblem::validateVariableNumericType(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VolumeAux::VolumeAux(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), XYFrontalDelaunayGenerator::XYFrontalDelaunayGenerator(), XYMeshLineCutter::XYMeshLineCutter(), XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

parameters()

const InputParameters & MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns

The parameters of the object

Definition at line 131 of file MooseBase.h.

{ return _pars; }

Referenced by AddActionComponentAction::act(), CommonOutputAction::act(), CSGOnlyAction::act(), MeshOnlyAction::act(), SetupDebugAction::act(), SplitMeshAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxKernel(), MFEMProblem::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), MFEMProblem::addAuxVariable(), FEProblemBase::addBoundaryCondition(), MFEMProblem::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), FEProblemBase::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::addDefaultSteadyStateConvergence(), MFEMProblem::addDefaultWeakForm(), MFEMEigenproblem::addDefaultWeakForm(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MFEMProblem::addFESpace(), MFEMProblem::addFESpaceHierarchy(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), FEProblemBase::addFunctorMaterial(), MFEMProblem::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVGradientMethod(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVInterpolationMethod(), FEProblemBase::addFVKernel(), MFEMProblem::addGridFunction(), FEProblemBase::addHDGKernel(), MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), FEProblemBase::addIndicator(), MFEMProblem::addIndicator(), FEProblemBase::addInitialCondition(), MFEMProblem::addInitialCondition(), DiffusionPhysicsBase::addInitialConditions(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), FEProblemBase::addKernel(), MFEMProblem::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), MFEMProblem::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), MFEMProblem::addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), MFEMProblem::addObject(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), FEProblemBase::addPostprocessor(), MFEMProblem::addPostprocessor(), FEProblemBase::addPredictor(), MFEMProblem::addProblemComposer(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), MFEMProblem::addSubMesh(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), MFEMProblem::addTransfer(), FEProblemBase::addUserObject(), DisplacedProblem::addVariable(), MFEMEigenproblem::addVariable(), MFEMProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), MFEMProblem::addVectorPostprocessor(), MFEMProblem::addWeakForm(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), assemble_l2(), Moose::assemble_matrix(), Action::associateWithParameter(), AuxKernelBase::AuxKernelBase(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), MooseMesh::buildTypedMesh(), MeshGenerator::checkGetMesh(), PostprocessorInterface::checkParam(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), SampledOutput::cloneMesh(), Moose::compute_bounds(), Moose::compute_jacobian(), Moose::compute_nearnullspace(), Moose::compute_nullspace(), Moose::compute_postcheck(), Moose::compute_transpose_nullspace(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), MooseMeshUtils::copyIntoMesh(), CommonOutputAction::create(), MultiApp::createApp(), Postprocessor::declareValue(), DumpObjectsProblem::deduceNecessaryParameters(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), EigenProblemSolve::EigenProblemSolve(), ElementMaterialSampler::ElementMaterialSampler(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), Executor::Executor(), Exodus::Exodus(), ElementSubdomainModifierBase::extrapolatePolynomial(), FEProblem::FEProblem(), FixedPointSolve::FixedPointSolve(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), GapValueAux::GapValueAux(), ParsedSubdomainGeneratorBase::generate(), ActionWarehouse::getCurrentActionName(), ExecutorInterface::getExecutor(), Material::getMaterial(), Moose::PeriodicBCHelper::getParams(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), UserObjectInterface::getUserObjectName(), AuxKernelBase::getVariableHelper(), VectorPostprocessorInterface::getVectorPostprocessorName(), GhostingUserObject::GhostingUserObject(), MeshGeneratorSystem::hasDataDrivenAllowed(), AttribSystem::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), FullSolveMultiApp::initialSetup(), FEProblemBase::initNullSpaceVectors(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MooseObject::isKokkosObject(), isValid(), IterationAdaptiveDT::IterationAdaptiveDT(), MooseApp::MooseApp(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableInterface< T >::MooseVariableInterface(), MultiApp::MultiApp(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodeFaceConstraint::NodeFaceConstraint(), ConsoleUtils::outputLegacyInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), PenetrationAux::PenetrationAux(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), NEML2Action::printSummary(), ProjectedStatefulMaterialStorageAction::processProperty(), PropertyReadFile::PropertyReadFile(), PseudoTimestep::PseudoTimestep(), RandomIC::RandomIC(), ReferenceResidualConvergence::ReferenceResidualConvergence(), InputParameterWarehouse::removeInputParameters(), FEProblemBase::setAuxKernelParamsAndLog(), FEProblemBase::setInputParametersFEProblem(), FEProblem::setInputParametersFEProblem(), FEProblemBase::setResidualObjectParamsAndLog(), SideSetsGeneratorBase::setup(), NonlinearSystemBase::shouldEvaluatePreSMOResidual(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), Moose::PetscSupport::storePetscOptions(), DumpObjectsProblem::stringifyParameters(), TaggingInterface::TaggingInterface(), Transfer::Transfer(), TransientBase::TransientBase(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), and VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl().

paramInfo()

template<typename... Args>

void MooseBase::paramInfo ( const std::string &  param, Args...  args  ) const

inherited

Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseInfo - only printing a message using the given args.

Definition at line 471 of file MooseBase.h.

{
  mooseInfo(_pars.paramMessage(param, std::forward<Args>(args)...));
}

Referenced by GridPartitioner::_do_partition(), ComboMarker::ComboMarker(), Control::Control(), FEProblemBase::execMultiApps(), FunctorIC::FunctorIC(), and TransientMultiApp::TransientMultiApp().

paramWarning() [1/2]

template<typename... Args>

void MooseBase::paramWarning ( const std::string &  param, Args...  args  ) const

inherited

Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseWarning - only printing a message using the given args.

Definition at line 464 of file MooseBase.h.

{
  mooseWarning(_pars.paramMessage(param, std::forward<Args>(args)...));
}

paramWarning() [2/2]

template<typename... Args>

void SolutionInvalidInterface::paramWarning ( const std::string &  param, Args...  args  ) const

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::paramWarning(param, std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning for parameter '" +
                                            param + "'");
  }

Referenced by GridPartitioner::_do_partition(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), MooseMeshUtils::copyIntoMesh(), CylindricalGridDivision::CylindricalGridDivision(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), PlaneIDMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), ReferenceResidualConvergence::initialSetup(), SolutionIC::initialSetup(), FullSolveMultiApp::initialSetup(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), MultiAppTransfer::MultiAppTransfer(), PNGOutput::PNGOutput(), FEProblemBase::setPreserveMatrixSparsityPattern(), Terminator::Terminator(), and SolutionAux::validateVariable().

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

{
  return _pg_moose_app.perfGraph();
}

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), PerfGraphReporter::finalize(), and PerfGraphOutput::output().

prepare() [1/2]

virtual void SubProblem::prepare ( const Elem *  elem, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by ElementalVariableValue::execute().

prepare() [2/2]

virtual void SubProblem::prepare ( const Elem *  elem, unsigned int  ivar, unsigned int  jvar, const std::vector< dof_id_type > &  dof_indices, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

prepareAssembly()

virtual void SubProblem::prepareAssembly ( const THREAD_ID  tid )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

prepareFace()

virtual void SubProblem::prepareFace ( const Elem *  elem, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

prepareFaceShapes()

virtual void SubProblem::prepareFaceShapes ( unsigned int  var, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by IntegratedBCBase::prepareShapes(), DGKernelBase::prepareShapes(), and InterfaceKernelBase::prepareShapes().

prepareNeighborShapes()

virtual void SubProblem::prepareNeighborShapes ( unsigned int  var, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by NeighborResidualObject::prepareNeighborShapes().

preparePRefinement()

void SubProblem::preparePRefinement

(

)

Prepare DofMap and Assembly classes with our p-refinement information.

Definition at line 1337 of file SubProblem.C.

{
  for (const auto tid : make_range(numThreads()))
    for (const auto s : make_range(numNonlinearSystems()))
      assembly(tid, s).preparePRefinement();
}

Referenced by FEProblemBase::init().

prepareShapes()

virtual void SubProblem::prepareShapes ( unsigned int  var, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by ResidualObject::prepareShapes().

queryParam()

template<typename T >

const T * MooseBase::queryParam ( const std::string &  name ) const

inherited

Query a parameter for the object.

If a parameter of the given name and type does not exist or if the parameter is not valid, nullptr will be returned

Parameters

name	The name of the parameter

Returns

A pointer to the parameter value, if it exists

Definition at line 413 of file MooseBase.h.

{
  return _pars.queryParam<T>(name);
}

Referenced by MFEMExecutedObject::getRequestedItems(), and MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver().

registerInvalidSolutionInternal()

InvalidSolutionID SolutionInvalidInterface::registerInvalidSolutionInternal ( const std::string &  message, const bool  warning  ) const

protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

{
  return moose::internal::getSolutionInvalidityRegistry().registerInvalidity(
      _si_moose_base.type(), message, warning);
}

registerTimedSection() [1/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name, const unsigned int  level  ) const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns

The ID of the section - use when starting timing

Definition at line 61 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

registerTimedSection() [2/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name, const unsigned int  level, const std::string &  live_message, const bool  print_dots = true  ) const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)
live_message	The message to be printed to the screen during execution
print_dots	Whether or not progress dots should be printed for this section

Returns

The ID of the section - use when starting timing

Definition at line 72 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(
        timedSectionName(section_name), level, live_message, print_dots);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

registerUnfilledFunctorRequest()

template<typename T >

void SubProblem::registerUnfilledFunctorRequest	(	T *	functor_interface,
		const std::string &	functor_name,
		const THREAD_ID	tid
	)

Register an unfulfilled functor request.

reinitDirac()

virtual bool SubProblem::reinitDirac ( const Elem *  elem, const THREAD_ID  tid  )

pure virtual

Returns true if the Problem has Dirac kernels it needs to compute on elem.

Implemented in DisplacedProblem, and FEProblemBase.

reinitElem()

virtual void SubProblem::reinitElem ( const Elem *  elem, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by ElementalVariableValue::execute().

reinitElemFace()

virtual void SubProblem::reinitElemFace ( const Elem *  elem, unsigned int  side, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

reinitElemFaceRef()

void SubProblem::reinitElemFaceRef ( const Elem *  elem, unsigned int  side, Real  tolerance, const std::vector< Point > *const  pts, const std::vector< Real > *const  weights = nullptr, const THREAD_ID  tid = 0  )

virtual

reinitialize FE objects on a given element on a given side at a given set of reference points and then compute variable data.

Note that this method makes no assumptions about what's been called beforehand, e.g. you don't have to call some prepare method before this one. This is an all-in-one reinit

Reimplemented in FEProblemBase.

Definition at line 874 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
  {
    // - Set our _current_elem for proper dof index getting in the moose variables
    // - Reinitialize all of our FE objects so we have current phi, dphi, etc. data
    // Note that our number of shape functions will reflect the number of shapes associated with the
    // interior element while the number of quadrature points will be determined by the passed pts
    // parameter (which presumably will have a number of pts reflective of a facial quadrature rule)
    assembly(tid, nl_sys_num).reinitElemFaceRef(elem, side, tolerance, pts, weights);
 
    auto & nl = systemBaseNonlinear(nl_sys_num);
 
    // Actually get the dof indices in the moose variables
    nl.prepare(tid);
 
    // Let's finally compute our variable values!
    nl.reinitElemFace(elem, side, tid);
  }
 
  // do same for aux as for nl
  systemBaseAuxiliary().prepare(tid);
  systemBaseAuxiliary().reinitElemFace(elem, side, tid);
 
  // With the dof indices set in the moose variables, now let's properly size
  // our local residuals/Jacobians
  auto & current_assembly = assembly(tid, currentNlSysNum());
  if (currentlyComputingJacobian() || currentlyComputingResidualAndJacobian())
    current_assembly.prepareJacobianBlock();
  if (!currentlyComputingJacobian())
    current_assembly.prepareResidual();
}

Referenced by FEProblemBase::reinitElemFaceRef().

reinitElemNeighborAndLowerD()

virtual void SubProblem::reinitElemNeighborAndLowerD ( const Elem *  elem, unsigned int  side, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

reinitElemPhys()

virtual void SubProblem::reinitElemPhys ( const Elem *  elem, const std::vector< Point > &  phys_points_in_elem, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), PointVariableSamplerBase::execute(), MultiAppVariableValueSampleTransfer::execute(), and FindValueOnLine::getValueAtPoint().

reinitFVFace()

void SubProblem::reinitFVFace	(	const THREAD_ID	tid,
		const FaceInfo &	fi
	)

reinitialize the finite volume assembly data for the provided face and thread

Definition at line 1289 of file SubProblem.C.

{
  for (const auto nl : make_range(numNonlinearSystems()))
    assembly(tid, nl).reinitFVFace(fi);
}

reinitGeomSearch()

void SubProblem::reinitGeomSearch

(

)

reinitialize this object's geometric search data, e.g.

do things like clear and re-add quadrature nodes

Definition at line 1373 of file SubProblem.C.

{
  geomSearchData().reinit();
}

reinitLowerDElem()

void SubProblem::reinitLowerDElem ( const Elem *  lower_d_elem, const THREAD_ID  tid, const std::vector< Point > *const  pts = nullptr, const std::vector< Real > *const  weights = nullptr  )

virtual

Reimplemented in FEProblemBase.

Definition at line 949 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
  {
    // - Set our _current_lower_d_elem for proper dof index getting in the moose variables
    // - Reinitialize all of our lower-d FE objects so we have current phi, dphi, etc. data
    assembly(tid, nl_sys_num).reinitLowerDElem(elem, pts, weights);
 
    auto & nl = systemBaseNonlinear(nl_sys_num);
 
    // Actually get the dof indices in the moose variables
    nl.prepareLowerD(tid);
 
    // With the dof indices set in the moose variables, now let's properly size
    // our local residuals/Jacobians
    assembly(tid, nl_sys_num).prepareLowerD();
 
    // Let's finally compute our variable values!
    nl.reinitLowerD(tid);
  }
 
  // do same for aux as for nl
  systemBaseAuxiliary().prepareLowerD(tid);
  systemBaseAuxiliary().reinitLowerD(tid);
}

Referenced by Moose::Mortar::loopOverMortarSegments(), DisplacedProblem::reinitElemNeighborAndLowerD(), and FEProblemBase::reinitLowerDElem().

reinitMortarElem()

void SubProblem::reinitMortarElem	(	const Elem *	elem,
		const THREAD_ID	tid = 0
	)

Reinit a mortar element to obtain a valid JxW.

Definition at line 1002 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    assembly(tid, nl_sys_num).reinitMortarElem(elem);
}

Referenced by Moose::Mortar::loopOverMortarSegments().

reinitNeighbor()

virtual void SubProblem::reinitNeighbor ( const Elem *  elem, unsigned int  side, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

reinitNeighborFaceRef()

void SubProblem::reinitNeighborFaceRef ( const Elem *  neighbor_elem, unsigned int  neighbor_side, Real  tolerance, const std::vector< Point > *const  pts, const std::vector< Real > *const  weights = nullptr, const THREAD_ID  tid = 0  )

virtual

reinitialize FE objects on a given neighbor element on a given side at a given set of reference points and then compute variable data.

Note that this method makes no assumptions about what's been called beforehand, e.g. you don't have to call some prepare method before this one. This is an all-in-one reinit

Reimplemented in FEProblemBase.

Definition at line 913 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
  {
    // - Set our _current_neighbor_elem for proper dof index getting in the moose variables
    // - Reinitialize all of our FE objects so we have current phi, dphi, etc. data
    // Note that our number of shape functions will reflect the number of shapes associated with the
    // interior element while the number of quadrature points will be determined by the passed pts
    // parameter (which presumably will have a number of pts reflective of a facial quadrature rule)
    assembly(tid, nl_sys_num)
        .reinitNeighborFaceRef(neighbor_elem, neighbor_side, tolerance, pts, weights);
 
    auto & nl = systemBaseNonlinear(nl_sys_num);
 
    // Actually get the dof indices in the moose variables
    nl.prepareNeighbor(tid);
 
    // Let's finally compute our variable values!
    nl.reinitNeighborFace(neighbor_elem, neighbor_side, tid);
  }
 
  // do same for aux as for nl
  systemBaseAuxiliary().prepareNeighbor(tid);
  systemBaseAuxiliary().reinitNeighborFace(neighbor_elem, neighbor_side, tid);
 
  // With the dof indices set in the moose variables, now let's properly size
  // our local residuals/Jacobians
  assembly(tid, currentNlSysNum()).prepareNeighbor();
}

Referenced by FEProblemBase::reinitNeighborFaceRef().

reinitNeighborLowerDElem()

void SubProblem::reinitNeighborLowerDElem	(	const Elem *	elem,
		const THREAD_ID	tid = 0
	)

reinitialize a neighboring lower dimensional element

Definition at line 995 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    assembly(tid, nl_sys_num).reinitNeighborLowerDElem(elem);
}

Referenced by Moose::Mortar::loopOverMortarSegments().

reinitNeighborPhys() [1/2]

virtual void SubProblem::reinitNeighborPhys ( const Elem *  neighbor, const std::vector< Point > &  physical_points, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

reinitNeighborPhys() [2/2]

virtual void SubProblem::reinitNeighborPhys ( const Elem *  neighbor, unsigned int  neighbor_side, const std::vector< Point > &  physical_points, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), and NonlinearSystemBase::reinitNodeFace().

reinitNode()

virtual void SubProblem::reinitNode ( const Node *  node, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

reinitNodeFace()

virtual void SubProblem::reinitNodeFace ( const Node *  node, BoundaryID  bnd_id, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

reinitNodes()

void SubProblem::reinitNodes	(	const std::vector< dof_id_type > &	nodes,
		const THREAD_ID	tid
	)

Definition at line 979 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    systemBaseNonlinear(nl_sys_num).reinitNodes(nodes, tid);
  systemBaseAuxiliary().reinitNodes(nodes, tid);
}

Referenced by AuxNodalScalarKernel::compute(), NodalScalarKernel::reinit(), and NodalConstraint::reinitConstraintNodes().

reinitNodesNeighbor()

void SubProblem::reinitNodesNeighbor	(	const std::vector< dof_id_type > &	nodes,
		const THREAD_ID	tid
	)

Definition at line 987 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    systemBaseNonlinear(nl_sys_num).reinitNodesNeighbor(nodes, tid);
  systemBaseAuxiliary().reinitNodesNeighbor(nodes, tid);
}

Referenced by NodalConstraint::reinitConstraintNodes().

reinitOffDiagScalars()

virtual void SubProblem::reinitOffDiagScalars ( const THREAD_ID  tid )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

reinitScalars()

virtual void SubProblem::reinitScalars ( const THREAD_ID  tid, bool  reinit_for_derivative_reordering = false  )

pure virtual

fills the VariableValue arrays for scalar variables from the solution vector

Parameters

tid	The thread id
reinit_for_derivative_reordering	A flag indicating whether we are reinitializing for the purpose of re-ordering derivative information for ADNodalBCs

Implemented in DisplacedProblem, and FEProblemBase.

removeAlgebraicGhostingFunctor()

void SubProblem::removeAlgebraicGhostingFunctor

(

libMesh::GhostingFunctor &

algebraic_gf

)

Remove an algebraic ghosting functor from this problem's DofMaps.

Definition at line 1075 of file SubProblem.C.

{
  EquationSystems & eq = es();
  const auto n_sys = eq.n_systems();
  DofMap & nl_dof_map = eq.get_system(0).get_dof_map();
 
  const bool found_in_root_sys =
      std::find(nl_dof_map.algebraic_ghosting_functors_begin(),
                nl_dof_map.algebraic_ghosting_functors_end(),
                &algebraic_gf) != nl_dof_map.algebraic_ghosting_functors_end();
 
#ifndef NDEBUG
  const bool found_in_our_map =
      _root_alg_gf_to_sys_clones.find(&algebraic_gf) != _root_alg_gf_to_sys_clones.end();
  mooseAssert(found_in_root_sys == found_in_our_map,
              "If the ghosting functor exists in the root DofMap, then we need to have a key for "
              "it in our gf to clones map");
#endif
 
  if (found_in_root_sys) // libMesh yells if we try to remove
                         // something that's not there
    nl_dof_map.remove_algebraic_ghosting_functor(algebraic_gf);
 
  auto it = _root_alg_gf_to_sys_clones.find(&algebraic_gf);
  if (it == _root_alg_gf_to_sys_clones.end())
    return;
 
  auto & clones_vec = it->second;
  mooseAssert((n_sys - 1) == clones_vec.size(),
              "The size of the gf clones vector doesn't match the number of systems minus one");
  if (clones_vec.empty())
  {
    mooseAssert(n_sys == 1, "The clones vector should only be empty if there is only one system");
    return;
  }
 
  for (const auto i : make_range(n_sys))
    eq.get_system(i + 1).get_dof_map().remove_algebraic_ghosting_functor(*clones_vec[i]);
 
  _root_alg_gf_to_sys_clones.erase(it->first);
}

removeCouplingGhostingFunctor()

void SubProblem::removeCouplingGhostingFunctor

(

libMesh::GhostingFunctor &

coupling_gf

)

Remove a coupling ghosting functor from this problem's DofMaps.

Definition at line 1118 of file SubProblem.C.

{
  EquationSystems & eq = es();
  const auto num_nl_sys = numNonlinearSystems();
  if (!num_nl_sys)
    return;
 
  DofMap & nl_dof_map = eq.get_system(0).get_dof_map();
  const bool found_in_root_sys = std::find(nl_dof_map.coupling_functors_begin(),
                                           nl_dof_map.coupling_functors_end(),
                                           &coupling_gf) != nl_dof_map.coupling_functors_end();
 
#ifndef NDEBUG
  const bool found_in_our_map =
      _root_coupling_gf_to_sys_clones.find(&coupling_gf) != _root_coupling_gf_to_sys_clones.end();
  mooseAssert(found_in_root_sys == found_in_our_map,
              "If the ghosting functor exists in the root DofMap, then we need to have a key for "
              "it in our gf to clones map");
#endif
 
  if (found_in_root_sys) // libMesh yells if we try to remove
                         // something that's not there
    nl_dof_map.remove_coupling_functor(coupling_gf);
 
  auto it = _root_coupling_gf_to_sys_clones.find(&coupling_gf);
  if (it == _root_coupling_gf_to_sys_clones.end())
    return;
 
  auto & clones_vec = it->second;
  mooseAssert((num_nl_sys - 1) == clones_vec.size(),
              "The size of the gf clones vector doesn't match the number of systems minus one");
  if (clones_vec.empty())
  {
    mooseAssert(num_nl_sys == 1,
                "The clones vector should only be empty if there is only one nonlinear system");
    return;
  }
 
  for (const auto i : make_range(num_nl_sys))
    eq.get_system(i + 1).get_dof_map().remove_coupling_functor(*clones_vec[i]);
 
  _root_coupling_gf_to_sys_clones.erase(it->first);
}

residualSetup()

void SubProblem::residualSetup ( )

virtual

Reimplemented in DisplacedProblem, and FEProblemBase.

Definition at line 1204 of file SubProblem.C.

{
  for (auto & map : _pbblf_functors)
    for (auto & pr : map)
      pr.second->residualSetup();
}

Referenced by DisplacedProblem::residualSetup(), and FEProblemBase::residualSetup().

restrictionBoundaryCheckName()

std::string SubProblem::restrictionBoundaryCheckName ( BoundaryID  check_id )

private

Definition at line 775 of file SubProblem.C.

{
  return mesh().getMesh().get_boundary_info().sideset_name(check_id);
}

Referenced by checkBoundaryMatProps().

restrictionSubdomainCheckName()

std::string SubProblem::restrictionSubdomainCheckName ( SubdomainID  check_id )

private

Helper functions for checking MaterialProperties.

Definition at line 764 of file SubProblem.C.

{
  // TODO: Put a better a interface in MOOSE
  std::map<subdomain_id_type, std::string> & name_map = mesh().getMesh().set_subdomain_name_map();
  std::map<subdomain_id_type, std::string>::const_iterator pos = name_map.find(check_id);
  if (pos != name_map.end())
    return pos->second;
  return "";
}

Referenced by checkBlockMatProps().

safeAccessTaggedMatrices()

virtual bool SubProblem::safeAccessTaggedMatrices ( ) const

inlinevirtual

Is it safe to access the tagged matrices.

Reimplemented in DisplacedProblem.

Definition at line 742 of file SubProblem.h.

{ return _safe_access_tagged_matrices; }

Referenced by MooseVariableScalar::reinit(), and DisplacedProblem::safeAccessTaggedMatrices().

safeAccessTaggedVectors()

virtual bool SubProblem::safeAccessTaggedVectors ( ) const

inlinevirtual

Is it safe to access the tagged vectors.

Reimplemented in DisplacedProblem.

Definition at line 745 of file SubProblem.h.

{ return _safe_access_tagged_vectors; }

Referenced by MooseVariableScalar::reinit(), and DisplacedProblem::safeAccessTaggedVectors().

selectMatrixTagsFromSystem()

void SubProblem::selectMatrixTagsFromSystem ( const SystemBase &  system, const std::map< TagName, TagID > &  input_matrix_tags, std::set< TagID > &  selected_tags  )

static

Select the matrix tags which belong to a specific system.

Parameters

system	Reference to the system
input_matrix_tags	A map of matrix tags
selected_tags	A set which gets populated by the tag-ids that belong to the system

Definition at line 292 of file SubProblem.C.

{
  selected_tags.clear();
  for (const auto & matrix_tag_pair : input_matrix_tags)
    if (system.hasMatrix(matrix_tag_pair.second))
      selected_tags.insert(matrix_tag_pair.second);
}

Referenced by FEProblemBase::computeLinearSystemSys().

selectVectorTagsFromSystem()

void SubProblem::selectVectorTagsFromSystem ( const SystemBase &  system, const std::vector< VectorTag > &  input_vector_tags, std::set< TagID > &  selected_tags  )

static

Select the vector tags which belong to a specific system.

Parameters

system	Reference to the system
input_vector_tags	A vector of vector tags
selected_tags	A set which gets populated by the tag-ids that belong to the system

Definition at line 281 of file SubProblem.C.

{
  selected_tags.clear();
  for (const auto & vector_tag : input_vector_tags)
    if (system.hasVector(vector_tag._id))
      selected_tags.insert(vector_tag._id);
}

Referenced by FEProblemBase::computeLinearSystemSys(), FEProblemBase::computeResidualAndJacobian(), and ComputeResidualAndJacobianThread::determineObjectWarehouses().

setActiveElementalMooseVariables()

void SubProblem::setActiveElementalMooseVariables ( const std::set< MooseVariableFieldBase * > &  moose_vars, const THREAD_ID  tid  )

virtual

Set the MOOSE variables to be reinited on each element.

Parameters

moose_vars	A set of variables that need to be reinited each time reinit() is called.
tid	The thread id

Reimplemented in FEProblemBase.

Definition at line 435 of file SubProblem.C.

{
  if (!moose_vars.empty())
  {
    _has_active_elemental_moose_variables[tid] = 1;
    _active_elemental_moose_variables[tid] = moose_vars;
  }
}

Referenced by FEProblemBase::setActiveElementalMooseVariables().

setActiveFEVariableCoupleableMatrixTags()

void SubProblem::setActiveFEVariableCoupleableMatrixTags ( std::set< TagID > &  mtags, const THREAD_ID  tid  )

virtual

Reimplemented in FEProblemBase.

Definition at line 355 of file SubProblem.C.

{
  _active_fe_var_coupleable_matrix_tags[tid] = mtags;
}

Referenced by FEProblemBase::setActiveFEVariableCoupleableMatrixTags().

setActiveFEVariableCoupleableVectorTags()

void SubProblem::setActiveFEVariableCoupleableVectorTags ( std::set< TagID > &  vtags, const THREAD_ID  tid  )

virtual

Reimplemented in FEProblemBase.

Definition at line 361 of file SubProblem.C.

{
  _active_fe_var_coupleable_vector_tags[tid] = vtags;
  for (const auto sys_num : make_range(numSolverSystems()))
    systemBaseSolver(sys_num).setActiveVariableCoupleableVectorTags(vtags, tid);
  systemBaseAuxiliary().setActiveVariableCoupleableVectorTags(vtags, tid);
}

Referenced by FEProblemBase::setActiveFEVariableCoupleableVectorTags().

setActiveScalarVariableCoupleableMatrixTags()

void SubProblem::setActiveScalarVariableCoupleableMatrixTags ( std::set< TagID > &  mtags, const THREAD_ID  tid  )

virtual

Reimplemented in FEProblemBase.

Definition at line 394 of file SubProblem.C.

{
  _active_sc_var_coupleable_matrix_tags[tid] = mtags;
}

Referenced by FEProblemBase::setActiveScalarVariableCoupleableMatrixTags().

setActiveScalarVariableCoupleableVectorTags()

void SubProblem::setActiveScalarVariableCoupleableVectorTags ( std::set< TagID > &  vtags, const THREAD_ID  tid  )

virtual

Reimplemented in FEProblemBase.

Definition at line 401 of file SubProblem.C.

{
  _active_sc_var_coupleable_vector_tags[tid] = vtags;
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    systemBaseNonlinear(nl_sys_num).setActiveScalarVariableCoupleableVectorTags(vtags, tid);
  systemBaseAuxiliary().setActiveScalarVariableCoupleableVectorTags(vtags, tid);
}

Referenced by FEProblemBase::setActiveScalarVariableCoupleableVectorTags().

setChainControlDataOutput()

void SubProblem::setChainControlDataOutput ( bool  set_output )

inline

Setter for debug chain control data output.

Definition at line 931 of file SubProblem.h.

{ _show_chain_control_data = set_output; }

setCurrentBoundaryID()

void SubProblem::setCurrentBoundaryID ( BoundaryID  bid, const THREAD_ID  tid  )

virtual

sets the current boundary ID in assembly

Reimplemented in FEProblemBase.

Definition at line 781 of file SubProblem.C.

{
  for (const auto sys_num : make_range(numSolverSystems()))
    assembly(tid, sys_num).setCurrentBoundaryID(bid);
}

Referenced by FEProblemBase::setCurrentBoundaryID().

setCurrentLowerDElem()

void SubProblem::setCurrentLowerDElem ( const Elem *const  lower_d_elem, const THREAD_ID  tid  )

virtual

Set the current lower dimensional element.

This can be null

Reimplemented in FEProblemBase.

Definition at line 1351 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    assembly(tid, nl_sys_num).setCurrentLowerDElem(lower_d_elem);
}

Referenced by FEProblemBase::setCurrentLowerDElem().

setCurrentlyComputingJacobian()

void SubProblem::setCurrentlyComputingJacobian ( const bool  currently_computing_jacobian )

inline

Set whether or not the problem is in the process of computing the Jacobian.

Definition at line 700 of file SubProblem.h.

  {
    _currently_computing_jacobian = currently_computing_jacobian;
  }

Referenced by FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::resetState().

setCurrentlyComputingResidual()

virtual void SubProblem::setCurrentlyComputingResidual ( const bool  currently_computing_residual )

inlinevirtual

Set whether or not the problem is in the process of computing the residual.

Reimplemented in FEProblemBase.

Definition at line 736 of file SubProblem.h.

  {
    _currently_computing_residual = currently_computing_residual;
  }

setCurrentlyComputingResidualAndJacobian()

void SubProblem::setCurrentlyComputingResidualAndJacobian ( bool  currently_computing_residual_and_jacobian )

inline

Set whether or not the problem is in the process of computing the Jacobian.

Definition at line 1489 of file SubProblem.h.

{
  _currently_computing_residual_and_jacobian = currently_computing_residual_and_jacobian;
}

Referenced by FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::resetState().

setCurrentSubdomainID()

virtual void SubProblem::setCurrentSubdomainID ( const Elem *  elem, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by PointVariableSamplerBase::execute(), MultiAppVariableValueSampleTransfer::execute(), GeometricSearchData::generateQuadratureNodes(), and GeometricSearchData::updateQuadratureNodes().

setFunctorOutput()

void SubProblem::setFunctorOutput ( bool  set_output )

inline

Setter for debug functor output.

Definition at line 929 of file SubProblem.h.

{ _show_functors = set_output; }

setNeighborSubdomainID()

virtual void SubProblem::setNeighborSubdomainID ( const Elem *  elem, unsigned int  side, const THREAD_ID  tid  )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

setResidual()

virtual void SubProblem::setResidual ( libMesh::NumericVector< libMesh::Number > &  residual, const THREAD_ID  tid  )

pure virtual

setResidualNeighbor()

virtual void SubProblem::setResidualNeighbor ( libMesh::NumericVector< libMesh::Number > &  residual, const THREAD_ID  tid  )

pure virtual

showFunctorRequestors()

void SubProblem::showFunctorRequestors ( ) const

private

Lists all functors and all the objects that requested them.

Definition at line 1264 of file SubProblem.C.

{
  for (const auto & [functor, requestors] : _functor_to_requestors)
  {
    _console << "[DBG] Requestors for wrapped functor "
             << std::regex_replace(functor, std::regex("wraps_"), "") << std::endl;
    _console << "[DBG] " << MooseUtils::join(requestors, " ") << std::endl;
  }
}

Referenced by initialSetup().

showFunctors()

void SubProblem::showFunctors ( ) const

private

Lists all functors in the problem.

Definition at line 1252 of file SubProblem.C.

{
  _console << "[DBG] Wrapped functors found in Subproblem" << std::endl;
  std::string functor_names = "[DBG] ";
  for (const auto & functor_pair : _functors[0])
    functor_names += std::regex_replace(functor_pair.first, std::regex("wraps_"), "") + " ";
  if (functor_names.size())
    functor_names.pop_back();
  _console << functor_names << std::endl;
}

Referenced by initialSetup().

solverSysNum()

virtual unsigned int SubProblem::solverSysNum ( const SolverSystemName &  solver_sys_name ) const

pure virtual

Returns

the solver system number corresponding to the provided solver_sys_name

Implemented in FEProblemBase, and DisplacedProblem.

solverSystemConverged()

virtual bool SubProblem::solverSystemConverged ( const unsigned int  sys_num )

inlinevirtual

Returns

whether the given solver system sys_num is converged

Reimplemented in DisplacedProblem, EigenProblem, and FEProblemBase.

Definition at line 103 of file SubProblem.h.

{ return converged(sys_num); }

Referenced by converged(), and nlConverged().

storeBoundaryDelayedCheckMatProp()

void SubProblem::storeBoundaryDelayedCheckMatProp ( const std::string &  requestor, BoundaryID  boundary_id, const std::string &  name  )

virtual

Adds to a map based on boundary ids of material properties to validate.

Parameters

requestor	The MOOSE object name requesting the material property
boundary_id	The block id for the MaterialProperty
name	The name of the property

Definition at line 607 of file SubProblem.C.

{
  _map_boundary_material_props_check[boundary_id].insert(std::make_pair(requestor, name));
}

Referenced by MaterialPropertyInterface::checkMaterialProperty().

storeBoundaryMatPropName()

void SubProblem::storeBoundaryMatPropName ( BoundaryID  boundary_id, const std::string &  name  )

virtual

Adds the given material property to a storage map based on boundary ids.

This is method is called from within the Material class when the property is first registered.

Parameters

boundary_id	The block id for the MaterialProperty
name	The name of the property

Definition at line 581 of file SubProblem.C.

{
  _map_boundary_material_props[boundary_id].insert(name);
}

Referenced by MaterialBase::registerPropName().

storeBoundaryZeroMatProp()

void SubProblem::storeBoundaryZeroMatProp ( BoundaryID  boundary_id, const MaterialPropertyName &  name  )

virtual

Adds to a map based on boundary ids of material properties for which a zero value can be returned.

Thes properties are optional and will not trigger a missing material property error.

Parameters

boundary_id	The block id for the MaterialProperty
name	The name of the property

Definition at line 593 of file SubProblem.C.

{
  _zero_boundary_material_props[boundary_id].insert(name);
}

Referenced by MaterialBase::storeBoundaryZeroMatProp().

storeSubdomainDelayedCheckMatProp()

void SubProblem::storeSubdomainDelayedCheckMatProp ( const std::string &  requestor, SubdomainID  block_id, const std::string &  name  )

virtual

Adds to a map based on block ids of material properties to validate.

Parameters

block_id	The block id for the MaterialProperty
name	The name of the property

Definition at line 599 of file SubProblem.C.

{
  _map_block_material_props_check[block_id].insert(std::make_pair(requestor, name));
}

Referenced by MaterialPropertyInterface::checkMaterialProperty().

storeSubdomainMatPropName()

void SubProblem::storeSubdomainMatPropName ( SubdomainID  block_id, const std::string &  name  )

virtual

Adds the given material property to a storage map based on block ids.

This is method is called from within the Material class when the property is first registered.

Parameters

block_id	The block id for the MaterialProperty
name	The name of the property

Definition at line 575 of file SubProblem.C.

{
  _map_block_material_props[block_id].insert(name);
}

Referenced by MaterialBase::registerPropName().

storeSubdomainZeroMatProp()

void SubProblem::storeSubdomainZeroMatProp ( SubdomainID  block_id, const MaterialPropertyName &  name  )

virtual

Adds to a map based on block ids of material properties for which a zero value can be returned.

Thes properties are optional and will not trigger a missing material property error.

Parameters

block_id	The block id for the MaterialProperty
name	The name of the property

Definition at line 587 of file SubProblem.C.

{
  _zero_block_material_props[block_id].insert(name);
}

Referenced by MaterialBase::storeSubdomainZeroMatProp().

systemBaseAuxiliary() [1/2]

virtual const SystemBase & SubProblem::systemBaseAuxiliary ( ) const

pure virtual

Return the auxiliary system object as a base class reference.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by clearAllDofIndices(), hasAuxiliaryVariable(), reinitElemFaceRef(), reinitLowerDElem(), reinitNeighborFaceRef(), reinitNodes(), reinitNodesNeighbor(), setActiveFEVariableCoupleableVectorTags(), and setActiveScalarVariableCoupleableVectorTags().

systemBaseAuxiliary() [2/2]

virtual SystemBase & SubProblem::systemBaseAuxiliary ( )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

systemBaseLinear() [1/2]

virtual const SystemBase & SubProblem::systemBaseLinear ( const unsigned int  sys_num ) const

pure virtual

Return the linear system object as a base class reference given the system number.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by hasLinearVariable().

systemBaseLinear() [2/2]

virtual SystemBase & SubProblem::systemBaseLinear ( const unsigned int  sys_num )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

systemBaseNonlinear() [1/2]

virtual const SystemBase & SubProblem::systemBaseNonlinear ( const unsigned int  sys_num ) const

pure virtual

Return the nonlinear system object as a base class reference given the system number.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by addCouplingGhostingFunctor(), automaticScaling(), automaticScaling(), clearAllDofIndices(), cloneCouplingGhostingFunctor(), reinitElemFaceRef(), reinitLowerDElem(), reinitNeighborFaceRef(), reinitNodes(), reinitNodesNeighbor(), and setActiveScalarVariableCoupleableVectorTags().

systemBaseNonlinear() [2/2]

virtual SystemBase & SubProblem::systemBaseNonlinear ( const unsigned int  sys_num )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

systemBaseSolver() [1/2]

virtual const SystemBase & SubProblem::systemBaseSolver ( const unsigned int  sys_num ) const

pure virtual

Return the solver system object as a base class reference given the system number.

Implemented in DisplacedProblem, and FEProblemBase.

Referenced by setActiveFEVariableCoupleableVectorTags().

systemBaseSolver() [2/2]

virtual SystemBase & SubProblem::systemBaseSolver ( const unsigned int  sys_num )

pure virtual

Implemented in DisplacedProblem, and FEProblemBase.

terminateSolve()

virtual void Problem::terminateSolve ( )

inlinevirtualinherited

Allow objects to request clean termination of the solve.

Definition at line 37 of file Problem.h.

{ _termination_requested = true; };

Referenced by Terminator::execute(), WebServerControl::execute(), and TerminateChainControl::terminate().

timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string &  section_name ) const

protectedinherited

Returns

The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

{
  return _prefix.empty() ? section_name : _prefix + "::" + section_name;
}

Referenced by PerfGraphInterface::registerTimedSection(), and PerfGraphInterface::registerTimedSection().

timestepSetup()

void SubProblem::timestepSetup ( )

virtual

Reimplemented in DisplacedProblem, DumpObjectsProblem, and FEProblemBase.

Definition at line 1186 of file SubProblem.C.

{
  for (auto & map : _pbblf_functors)
    for (auto & pr : map)
      pr.second->timestepSetup();
  if (_show_chain_control_data)
    _console << _app.getChainControlDataSystem().outputChainControlMap() << std::flush;
}

Referenced by DisplacedProblem::timestepSetup(), and FEProblemBase::timestepSetup().

type()

const std::string & MooseBase::type ( ) const

inlineinherited

Get the type of this class.

Returns

the name of the type of this class

Definition at line 93 of file MooseBase.h.

  {
    mooseAssert(_type.size(), "Empty type");
    return _type;
  }

Referenced by CreateProblemDefaultAction::act(), MaterialOutputAction::act(), SetupDebugAction::act(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addConvergence(), MFEMProblem::addDefaultProblemComposer(), MFEMProblem::addDefaultWeakForm(), FEProblemBase::addDistribution(), DistributedRectilinearMeshGenerator::addElement(), DistributedRectilinearMeshGenerator::addElement(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), MFEMProblem::addFESpace(), MFEMProblem::addFESpaceHierarchy(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), MFEMProblem::addObject(), FEProblemBase::addObject(), DistributedRectilinearMeshGenerator::addPoint(), MFEMProblem::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), WebServerControl::addServerActionsInternal(), FEProblemBase::addTimeIntegrator(), MFEMProblem::addVectorPostprocessor(), addVectorTag(), DisplacedProblem::addVectorTag(), FEProblemBase::advanceMultiApps(), MooseApp::appendMeshGenerator(), AuxKernelBase::AuxKernelBase(), FEProblemBase::backupMultiApps(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BoundaryPreservedMarker::BoundaryPreservedMarker(), DistributedRectilinearMeshGenerator::buildCube(), MooseMesh::buildHRefinementAndCoarseningMaps(), MooseMesh::buildLowerDMesh(), MooseMesh::buildPRefinementAndCoarseningMaps(), PhysicsBase::checkComponentType(), MeshGenerator::checkGetMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), FEProblemBase::checkUserObjectNameCollision(), MFEMMultiAppTransfer::checkValidTransferProblemTypes(), MeshInfo::CombinedInfos< ElemInfoMap, ElemInfoItems >::CombinedInfos(), ElemElemConstraint::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighJacobian(), DGKernel::computeElemNeighJacobian(), ADDGKernel::computeElemNeighJacobian(), ElemElemConstraint::computeElemNeighResidual(), ArrayDGKernel::computeElemNeighResidual(), DGKernel::computeElemNeighResidual(), ADDGKernel::computeElemNeighResidual(), ArrayDGLowerDKernel::computeLowerDJacobian(), DGLowerDKernel::computeLowerDJacobian(), ArrayLowerDIntegratedBC::computeLowerDJacobian(), LowerDIntegratedBC::computeLowerDJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayHFEMDirichletBC::computeLowerDQpJacobian(), HFEMDirichletBC::computeLowerDQpJacobian(), ArrayHFEMDiffusion::computeLowerDQpJacobian(), HFEMDiffusion::computeLowerDQpJacobian(), ArrayLowerDIntegratedBC::computeLowerDQpOffDiagJacobian(), ArrayDGLowerDKernel::computeLowerDQpOffDiagJacobian(), ArrayHFEMDirichletBC::computeLowerDQpOffDiagJacobian(), HFEMDirichletBC::computeLowerDQpOffDiagJacobian(), FEProblemBase::computeMultiAppsDT(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), DGKernel::computeOffDiagElemNeighJacobian(), ADDGKernel::computeOffDiagElemNeighJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ScalarKernel::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), DGConvection::computeQpJacobian(), ArrayDGDiffusion::computeQpJacobian(), DGDiffusion::computeQpJacobian(), InterfaceDiffusion::computeQpJacobian(), InterfaceReaction::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), ArrayDGKernel::computeQpOffDiagJacobian(), HFEMTestJump::computeQpOffDiagJacobian(), HFEMTrialJump::computeQpOffDiagJacobian(), ScalarKernel::computeQpResidual(), CoupledTiedValueConstraint::computeQpResidual(), EqualValueBoundaryConstraint::computeQpResidual(), LinearNodalConstraint::computeQpResidual(), TiedValueConstraint::computeQpResidual(), DGConvection::computeQpResidual(), ADDGAdvection::computeQpResidual(), ADDGDiffusion::computeQpResidual(), DGDiffusion::computeQpResidual(), HFEMDiffusion::computeQpResidual(), HFEMTestJump::computeQpResidual(), HFEMTrialJump::computeQpResidual(), ADMatInterfaceReaction::computeQpResidual(), InterfaceDiffusion::computeQpResidual(), InterfaceReaction::computeQpResidual(), ArrayDGDiffusion::computeQpResidual(), ArrayHFEMDiffusion::computeQpResidual(), FEProblemBase::computeSystems(), FEProblemBase::computeUserObjectByName(), FEProblemBase::computeUserObjects(), FEProblemBase::computeUserObjectsInternal(), FEProblemBase::createQRules(), DisplacedProblem::createQRules(), MooseApp::createRecoverablePerfGraph(), MoveBoundaryNodesToCurveGenerator::curveGenerator(), MeshGenerator::declareMeshProperty(), DumpObjectsProblem::deduceNecessaryParameters(), DumpObjectsProblem::dumpObjectHelper(), FEProblemBase::duplicateVariableCheck(), FEProblemBase::execMultiAppTransfers(), SteadyBase::execute(), WebServerControl::execute(), ActionWarehouse::executeActionsWithAction(), FEProblemBase::finishMultiAppStep(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), SubdomainPerElementGenerator::generate(), PatternedMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), MultiAppTransfer::getAppInfo(), TransfiniteMeshGenerator::getEdge(), ElementGenerator::getElemType(), FEProblemBase::getMaterial(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), MaterialOutputAction::getParams(), ReporterData::getReporterInfo(), MooseServer::getSyntaxMetadata(), FEProblemBase::getTransfers(), FEProblemBase::getUOQuery(), getVectorTags(), DisplacedProblem::getVectorTags(), EqualValueBoundaryConstraint::ghostPrimary(), CommonOutputAction::hasConsole(), FEProblemBase::hasMultiApps(), AdvancedOutput::hasOutput(), FEProblemBase::incrementMultiAppTStep(), NEML2Action::inferMOOSEIOType(), AdvancedOutput::initAvailableLists(), FunctorPositions::initialize(), FunctorTimes::initialize(), LinearFVAdvection::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), LinearFVDiffusion::initialSetup(), MultiAppConservativeTransfer::initialSetup(), ArrayDGDiffusion::initQpResidual(), AdvancedOutput::initShowHideLists(), RelationshipManager::isType(), FEProblemBase::logAdd(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MooseApp::MooseApp(), MooseObject::MooseObject(), numVectorTags(), DisplacedProblem::numVectorTags(), AdvancedOutput::output(), Console::output(), ConsoleUtils::outputExecutionInformation(), Output::outputStep(), SampledOutput::outputStep(), FEProblemBase::outputStep(), MooseServer::parseDocumentForDiagnostics(), PointInUnionCheckUO::PointInUnionCheckUO(), MooseMesh::prepare(), MFEMFunctorMaterial::processLiterals(), ProjectedStatefulMaterialStorageAction::processProperty(), MooseApp::recursivelyCreateExecutors(), SolutionInvalidInterface::registerInvalidSolutionInternal(), FEProblemBase::restoreMultiApps(), MeshRepairGenerator::separateSubdomainsByElementType(), FEProblemBase::setCoupling(), MooseApp::setupOptions(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), Reporter::store(), MooseBase::typeAndName(), AuxScalarKernel::uOld(), ScalarKernelBase::uOld(), DisplacedProblem::updateGeomSearch(), FEProblemBase::updateGeomSearch(), UserObjectInterface::userObjectType(), and AdvancedOutput::wantOutput().

typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

Get the class's combined type and name; useful in error handling.

Returns

The type and name of this class in the form '<type()> "<name()>"'.

Definition at line 57 of file MooseBase.C.

{
  return type() + std::string(" \"") + name() + std::string("\"");
}

Referenced by MaterialPropertyStorage::addProperty(), FEProblemBase::checkUserObjectNameCollision(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< T >::finalize(), ReporterData::getReporterInfo(), MFEMSamplerBase::initialSetup(), MFEMVariableSamplerBase::initialSetup(), WebServerControl::outputMessage(), and Action::timedAct().

uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

Returns

The unique name for accessing input parameters of this object in the InputParameterWarehouse

Definition at line 69 of file MooseBase.C.

{
  if (!_pars.have_parameter<std::string>(unique_name_param))
    mooseError("uniqueName(): Object does not have a unique name");
  return MooseObjectName(_pars.get<std::string>(unique_name_param));
}

Referenced by MooseBase::connectControllableParams(), and Action::uniqueActionName().

uniqueParameterName()

MooseObjectParameterName MooseBase::uniqueParameterName ( const std::string &  parameter_name ) const

inherited

Returns

The unique parameter name of a valid parameter of this object for accessing parameter controls

Definition at line 63 of file MooseBase.C.

{
  return MooseObjectParameterName(getBase(), name(), parameter_name);
}

updateGeomSearch()

virtual void SubProblem::updateGeomSearch ( GeometricSearchData::GeometricSearchType  type = GeometricSearchData::ALL )

pure virtual

update geometric search data

Implemented in DisplacedProblem, and FEProblemBase.

validParams()

InputParameters SubProblem::validParams ( )

static

Definition at line 34 of file SubProblem.C.

{
  InputParameters params = Problem::validParams();
 
  params.addParam<bool>(
      "default_ghosting",
      false,
      "Whether or not to use libMesh's default amount of algebraic and geometric ghosting");
 
  params.addParamNamesToGroup("default_ghosting", "Advanced");
 
  return params;
}

Referenced by DisplacedProblem::validParams(), and FEProblemBase::validParams().

vectorTagExists() [1/2]

virtual bool SubProblem::vectorTagExists ( const TagID  tag_id ) const

inlinevirtual

Check to see if a particular Tag exists.

Reimplemented in DisplacedProblem.

Definition at line 204 of file SubProblem.h.

{ return tag_id < _vector_tags.size(); }

Referenced by SystemBase::addVector(), SystemBase::associateVectorToTag(), SystemBase::closeTaggedVector(), FEProblemBase::computePostCheck(), Coupleable::coupledVectorTagArrayGradient(), Coupleable::coupledVectorTagArrayGradient(), Coupleable::coupledVectorTagArrayGradients(), Coupleable::coupledVectorTagArrayValues(), Coupleable::coupledVectorTagDofValues(), Coupleable::coupledVectorTagGradient(), Coupleable::coupledVectorTagGradient(), Coupleable::coupledVectorTagGradients(), ScalarCoupleable::coupledVectorTagScalarValue(), Coupleable::coupledVectorTagValues(), SystemBase::disassociateDefaultVectorTags(), SystemBase::disassociateVectorFromTag(), SystemBase::disassociateVectorFromTag(), SystemBase::getVector(), SystemBase::getVector(), getVectorTag(), FEProblemBase::needsPreviousNewtonIteration(), FEProblemBase::needsPreviousNewtonIteration(), SystemBase::removeVector(), TaggingInterface::useVectorTag(), TaggingInterface::useVectorTag(), Coupleable::vectorTagDofValueHelper(), DisplacedProblem::vectorTagExists(), DisplacedProblem::vectorTagExists(), vectorTagName(), vectorTagType(), Coupleable::vectorTagValueHelper(), Coupleable::vectorTagValueHelper(), and SystemBase::zeroTaggedVector().

vectorTagExists() [2/2]

bool SubProblem::vectorTagExists ( const TagName &  tag_name ) const

virtual

Check to see if a particular Tag exists by using Tag name.

Reimplemented in DisplacedProblem.

Definition at line 128 of file SubProblem.C.

{
  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
 
  const auto tag_name_upper = MooseUtils::toUpper(tag_name);
  for (const auto & vector_tag : _vector_tags)
    if (vector_tag._name == tag_name_upper)
      return true;
 
  return false;
}

vectorTagName()

TagName SubProblem::vectorTagName ( const TagID  tag ) const

virtual

Retrieve the name associated with a TagID.

Reimplemented in DisplacedProblem.

Definition at line 213 of file SubProblem.C.

{
  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
  if (!vectorTagExists(tag_id))
    mooseError("Vector tag with ID ", tag_id, " does not exist");
 
  return _vector_tags[tag_id]._name;
}

Referenced by SystemBase::addVector(), SystemBase::closeTaggedVector(), NonlinearSystemBase::getResidualNonTimeVector(), NonlinearSystemBase::getResidualTimeVector(), SystemBase::removeVector(), NonlinearSystemBase::residualGhosted(), DisplacedProblem::vectorTagName(), and SystemBase::zeroTaggedVector().

vectorTagNotZeroed()

bool SubProblem::vectorTagNotZeroed

(

const TagID

tag

)

const

Checks if a vector tag is in the list of vectors that will not be zeroed when other tagged vectors are.

Parameters

tag	the TagID of the vector that is currently being checked

Returns

false if the tag is not within the set of vectors that are intended to not be zero or if the set is empty. returns true otherwise

Definition at line 147 of file SubProblem.C.

{
  return _not_zeroed_tagged_vectors.count(tag);
}

Referenced by SystemBase::zeroTaggedVector().

vectorTagType()

Moose::VectorTagType SubProblem::vectorTagType ( const TagID  tag_id ) const

virtual

Reimplemented in DisplacedProblem.

Definition at line 223 of file SubProblem.C.

{
  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
  if (!vectorTagExists(tag_id))
    mooseError("Vector tag with ID ", tag_id, " does not exist");
 
  return _vector_tags[tag_id]._type;
}

Referenced by MooseVariableScalar::reinit(), TaggingInterface::TaggingInterface(), TagVectorAux::TagVectorAux(), and DisplacedProblem::vectorTagType().

verifyVectorTags()

bool SubProblem::verifyVectorTags ( ) const

protected

Verify the integrity of _vector_tags and _typed_vector_tags.

Definition at line 233 of file SubProblem.C.

{
  for (TagID tag_id = 0; tag_id < _vector_tags.size(); ++tag_id)
  {
    const auto & vector_tag = _vector_tags[tag_id];
 
    if (vector_tag._id != tag_id)
      mooseError("Vector tag ", vector_tag._id, " id mismatch in _vector_tags");
    if (vector_tag._type == Moose::VECTOR_TAG_ANY)
      mooseError("Vector tag '", vector_tag._name, "' has type VECTOR_TAG_ANY");
 
    const auto search = _vector_tags_name_map.find(vector_tag._name);
    if (search == _vector_tags_name_map.end())
      mooseError("Vector tag ", vector_tag._id, " is not in _vector_tags_name_map");
    else if (search->second != tag_id)
      mooseError("Vector tag ", vector_tag._id, " has incorrect id in _vector_tags_name_map");
 
    unsigned int found_in_type = 0;
    for (TagTypeID tag_type_id = 0; tag_type_id < _typed_vector_tags[vector_tag._type].size();
         ++tag_type_id)
    {
      const auto & vector_tag_type = _typed_vector_tags[vector_tag._type][tag_type_id];
      if (vector_tag_type == vector_tag)
      {
        ++found_in_type;
        if (vector_tag_type._type_id != tag_type_id)
          mooseError("Type ID for Vector tag ", tag_id, " is incorrect");
      }
    }
 
    if (found_in_type == 0)
      mooseError("Vector tag ", tag_id, " not found in _typed_vector_tags");
    if (found_in_type > 1)
      mooseError("Vector tag ", tag_id, " found multiple times in _typed_vector_tags");
  }
 
  unsigned int num_typed_vector_tags = 0;
  for (const auto & typed_vector_tags : _typed_vector_tags)
    num_typed_vector_tags += typed_vector_tags.size();
  if (num_typed_vector_tags != _vector_tags.size())
    mooseError("Size mismatch between _vector_tags and _typed_vector_tags");
  if (_vector_tags_name_map.size() != _vector_tags.size())
    mooseError("Size mismatch between _vector_tags and _vector_tags_name_map");
 
  return true;
}

Referenced by addVectorTag(), getVectorTag(), getVectorTagID(), getVectorTags(), getVectorTags(), numVectorTags(), vectorTagExists(), vectorTagName(), and vectorTagType().

Friends And Related Symbol Documentation

Restartable

friend class Restartable

friend

Definition at line 1205 of file SubProblem.h.

Member Data Documentation

_action_factory

ActionFactory& ParallelParamObject::_action_factory

protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

Referenced by AddActionComponentAction::act(), CreateMeshSetupActionsForComponents::act(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), CreateExecutionerAction::setupAutoPreconditioning(), and ReadExecutorParamsAction::setupAutoPreconditioning().

_active_elemental_moose_variables

std::vector<std::set<MooseVariableFieldBase *> > SubProblem::_active_elemental_moose_variables

protected

This is the set of MooseVariableFieldBase that will actually get reinited by a call to reinit(elem)

Definition at line 1076 of file SubProblem.h.

Referenced by clearActiveElementalMooseVariables(), getActiveElementalMooseVariables(), setActiveElementalMooseVariables(), and SubProblem().

_active_fe_var_coupleable_matrix_tags

std::vector<std::set<TagID> > SubProblem::_active_fe_var_coupleable_matrix_tags

protected

Definition at line 1082 of file SubProblem.h.

Referenced by clearActiveFEVariableCoupleableMatrixTags(), getActiveFEVariableCoupleableMatrixTags(), setActiveFEVariableCoupleableMatrixTags(), and SubProblem().

_active_fe_var_coupleable_vector_tags

std::vector<std::set<TagID> > SubProblem::_active_fe_var_coupleable_vector_tags

protected

Definition at line 1084 of file SubProblem.h.

Referenced by clearActiveFEVariableCoupleableVectorTags(), getActiveFEVariableCoupleableVectorTags(), setActiveFEVariableCoupleableVectorTags(), and SubProblem().

_active_sc_var_coupleable_matrix_tags

std::vector<std::set<TagID> > SubProblem::_active_sc_var_coupleable_matrix_tags

protected

Definition at line 1086 of file SubProblem.h.

Referenced by clearActiveScalarVariableCoupleableMatrixTags(), getActiveScalarVariableCoupleableMatrixTags(), setActiveScalarVariableCoupleableMatrixTags(), and SubProblem().

_active_sc_var_coupleable_vector_tags

std::vector<std::set<TagID> > SubProblem::_active_sc_var_coupleable_vector_tags

protected

Definition at line 1088 of file SubProblem.h.

Referenced by clearActiveScalarVariableCoupleableVectorTags(), getActiveScalarVariableCoupleableVectorTags(), setActiveScalarVariableCoupleableVectorTags(), and SubProblem().

_app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector(), FEProblemBase::acceptInvalidSolution(), FEProblemBase::addAnyRedistributers(), MeshGenerator::addChildMeshGenerator(), FEProblemBase::addMaterialHelper(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addOutput(), MeshGenerator::addParentMeshGenerator(), FEProblemBase::allowOutput(), AStableDirk4::AStableDirk4(), FileMesh::buildMesh(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), DefaultNonlinearConvergence::checkConvergence(), MeshGenerator::checkGetMesh(), FEProblemBase::checkICRestartError(), FEProblemBase::checkProblemIntegrity(), LibmeshPartitioner::clone(), BlockWeightedPartitioner::clone(), CopyMeshPartitioner::clone(), GridPartitioner::clone(), HierarchicalGridPartitioner::clone(), PetscExternalPartitioner::clone(), RandomPartitioner::clone(), SingleRankPartitioner::clone(), ElementPointNeighborLayers::clone(), ElementSideNeighborLayers::clone(), GhostAllPointNeighbors::clone(), GhostBoundary::clone(), GhostEverything::clone(), GhostHigherDLowerDPointNeighbors::clone(), GhostLowerDElems::clone(), GhostPrimaryFace::clone(), ProxyRelationshipManager::clone(), RedistributeProperties::clone(), SampledOutput::cloneMesh(), FEProblemBase::computeJacobianSys(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualSys(), FEProblemBase::computeResidualTags(), Console::Console(), TimeStepper::constrainStep(), Control::Control(), CopyMeshPartitioner::CopyMeshPartitioner(), MultiApp::createApp(), MultiApp::createApps(), MoveBoundaryNodesToCurveGenerator::curveGenerator(), FEProblemBase::customSetup(), MeshGenerator::declareMeshProperty(), MeshGenerator::declareNullMeshName(), MooseMesh::determineUseDistributedMesh(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), DumpObjectsProblem::dumpVariableHelper(), EigenExecutionerBase::EigenExecutionerBase(), EigenKernel::EigenKernel(), PIDTransientControl::execute(), Eigenvalue::execute(), InversePowerMethod::execute(), NonlinearEigen::execute(), SteadyBase::execute(), TransientBase::execute(), MFEMSteady::execute(), PseudoTimestep::execute(), IterationInfo::execute(), EigenProblem::execute(), Executioner::Executioner(), Executioner::Executioner(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), NEML2Assembly::finalize(), ChangeOverFixedPointPostprocessor::finalize(), RadialAverage::finalize(), FixedPointSolve::FixedPointSolve(), FEProblemBase::forceOutput(), FullSolveMultiApp::FullSolveMultiApp(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVAdvection::FVAdvection(), FileMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), MeshGenerator::getCSGBaseByName(), FEProblemBase::getExecutor(), MeshGenerator::getMeshByName(), NumFixedPointIterations::getValue(), NumRelationshipManagers::getValue(), GhostingUserObject::GhostingUserObject(), MooseMesh::init(), Eigenvalue::init(), InversePowerMethod::init(), NonlinearEigen::init(), TransientBase::init(), MFEMMesh::init(), FEProblemBase::init(), CompositionDT::init(), initialSetup(), PIDTransientControl::initialSetup(), RealFunctionControl::initialSetup(), TimePeriod::initialSetup(), EigenProblemSolve::initialSetup(), FEProblemSolve::initialSetup(), Console::initialSetup(), FEProblemBase::initialSetup(), BoundaryMeshBuilder::initialSetup(), AdvancedOutput::initOutputList(), FEProblemBase::initPetscOutputAndSomeSolverSettings(), EigenProblem::initPetscOutputAndSomeSolverSettings(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), FEProblemBase::meshChanged(), MeshGenerator::MeshGenerator(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh::MooseMesh(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), EigenExecutionerBase::normalizeSolution(), NumFailedTimeSteps::NumFailedTimeSteps(), Checkpoint::output(), Exodus::output(), Nemesis::output(), PerfGraphOutput::output(), Tecplot::output(), MortarNodalGeometryOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Exodus::outputEmptyTimestep(), Console::outputInput(), Exodus::outputInput(), Exodus::outputNodalVariables(), JSONOutput::outputReporters(), Output::outputStep(), SampledOutput::outputStep(), FEProblemBase::outputStep(), Console::outputSystemInformation(), JSONOutput::outputSystemInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MultiApp::parentOutputPositionChanged(), TransientBase::preExecute(), FEProblemBase::projectSolution(), AnnularMesh::safeClone(), ConcentricCircleMesh::safeClone(), FileMesh::safeClone(), GeneratedMesh::safeClone(), ImageMesh::safeClone(), MeshGeneratorMesh::safeClone(), PatternedMesh::safeClone(), RinglebMesh::safeClone(), SpiralAnnularMesh::safeClone(), StitchedMesh::safeClone(), TiledMesh::safeClone(), MFEMFileMesh::safeClone(), MFEMMeshGeneratorMesh::safeClone(), MultiApp::setAppOutputFileBase(), FileOutput::setFileBaseInternal(), MeshGenerator::setMeshProperty(), MeshGenerator::setMeshPropertyHelper(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), Output::setWallTimeIntervalFromCommandLineParam(), SideSetExtruderGenerator::SideSetExtruderGenerator(), SolutionInvalidityReporter::SolutionInvalidityReporter(), FixedPointSolve::solve(), ActuallyExplicitEuler::solve(), FEProblemBase::solve(), EigenProblem::solve(), FEProblemBase::solveLinearSystem(), PetscOutput::solveSetup(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), FEProblemBase::subdomainSetup(), FEProblemBase::theWarehouse(), TimeExtremeValue::TimeExtremeValue(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), timestepSetup(), PIDTransientControl::timestepSetup(), FEProblemBase::timestepSetup(), TransientBase::TransientBase(), MooseMesh::update(), NEML2FEInterpolation::updateDofMap(), NEML2FEInterpolation::updateGradPhi(), NEML2FEInterpolation::updateInterpolations(), FEProblemBase::updateMortarMesh(), NEML2FEInterpolation::updatePhi(), Console::write(), XYQuadrilateralMeshFromBoundaryCurve::XYQuadrilateralMeshFromBoundaryCurve(), and FEProblemBase::~FEProblemBase().

_cli_option_found

bool Problem::_cli_option_found

protectedinherited

True if the CLI option is found.

Definition at line 52 of file Problem.h.

Referenced by Problem::_setCLIOption().

_color_output

bool Problem::_color_output

protectedinherited

True if we're going to attempt to write color output.

Definition at line 55 of file Problem.h.

_computing_nonlinear_residual

bool SubProblem::_computing_nonlinear_residual

protected

Whether the non-linear residual is being evaluated.

Definition at line 1103 of file SubProblem.h.

Referenced by computingNonlinearResid(), FEProblemBase::computingNonlinearResid(), and computingNonlinearResid().

_console

const ConsoleStream ConsoleStreamInterface::_console

inherited

An instance of helper class to write streams to the Console objects.

Definition at line 31 of file ConsoleStreamInterface.h.

Referenced by IterationAdaptiveDT::acceptStep(), MaterialOutputAction::act(), MeshOnlyAction::act(), SetupDebugAction::act(), FEProblemBase::adaptMesh(), Adaptivity::adaptMesh(), PerfGraph::addToExecutionList(), SimplePredictor::apply(), SystemBase::applyScalingFactors(), MultiApp::backup(), FEProblemBase::backupMultiApps(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), DefaultSteadyStateConvergence::checkConvergence(), MeshDiagnosticsGenerator::checkElementOverlap(), MeshDiagnosticsGenerator::checkElementTypes(), MeshDiagnosticsGenerator::checkElementVolumes(), FEProblemBase::checkExceptionAndStopSolve(), SolverSystem::checkInvalidSolution(), MeshDiagnosticsGenerator::checkLocalJacobians(), MeshDiagnosticsGenerator::checkNonConformalMesh(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonConformingFaces(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), MeshDiagnosticsGenerator::checkPolygons(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkResidualConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), CoarsenSurfaceMeshAlongSidesetGenerator::coarsenAlongSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), FEProblemBase::computeLinearSystemTags(), LinearSystem::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), TimeStepper::constrainStep(), IterationAdaptiveDT::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), Eigenvalue::execute(), SteadyBase::execute(), MFEMSteady::execute(), MessageFromInput::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), SidesetAroundSubdomainUpdater::finalize(), ElementQualityChecker::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), SurfaceSubdomainsDelaunayRemesher::General2DDelaunay(), CoarsenBlockGenerator::generate(), CoarsenSurfaceMeshAlongSidesetGenerator::generate(), OrientSurfaceMeshGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), InversePowerMethod::init(), NonlinearEigen::init(), FEProblemBase::initialAdaptMesh(), initialSetup(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), SurfaceDelaunayGeneratorBase::meshNormalDeviation2D(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), Console::output(), DOFMapOutput::output(), MaterialPropertyDebugOutput::output(), PerfGraphOutput::output(), ReporterDebugOutput::output(), SolutionInvalidityOutput::output(), VariableResidualNormsDebugOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), WebServerControl::outputMessage(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), DefaultMultiAppFixedPointConvergence::preLoop(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), PicardSolve::printFixedPointConvergenceHistory(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), FixedPointSolve::printFixedPointConvergenceReason(), PerfGraphLivePrint::printLiveMessage(), MaterialPropertyDebugOutput::printMaterialMap(), PerfGraphLivePrint::printStats(), NEML2Action::printSummary(), AutomaticMortarGeneration::projectPrimaryNodesSinglePair(), AutomaticMortarGeneration::projectSecondaryNodesSinglePair(), CoarsenBlockGenerator::recursiveCoarsen(), SolutionTimeAdaptiveDT::rejectStep(), MultiApp::restore(), FEProblemBase::restoreMultiApps(), FEProblemBase::restoreSolutions(), NonlinearSystemBase::setInitialSolution(), MooseApp::setupOptions(), Checkpoint::shouldOutput(), showFunctorRequestors(), showFunctors(), FullSolveMultiApp::showStatusMessage(), FEProblemSolve::solve(), FixedPointSolve::solve(), LinearSystem::solve(), NonlinearSystem::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), EigenProblem::solve(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), PerfGraphLivePrint::start(), WebServerControl::startServer(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), TransientBase::takeStep(), MFEMTransient::takeStep(), TerminateChainControl::terminate(), timestepSetup(), FEProblemBase::updateMeshXFEM(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_consumed_material_properties

std::map<MooseObjectName, std::set<std::string> > SubProblem::_consumed_material_properties

private

Definition at line 1189 of file SubProblem.h.

Referenced by addConsumedPropertyName(), and getConsumedPropertyMap().

_currently_computing_jacobian

bool SubProblem::_currently_computing_jacobian

protected

Flag to determine whether the problem is currently computing Jacobian.

Definition at line 1097 of file SubProblem.h.

Referenced by FEProblemBase::computeJacobianBlocks(), EigenProblem::computeJacobianBlocks(), FEProblemBase::computeJacobianTags(), currentlyComputingJacobian(), and setCurrentlyComputingJacobian().

_currently_computing_residual

bool SubProblem::_currently_computing_residual

protected

Whether the residual is being evaluated.

Definition at line 1106 of file SubProblem.h.

Referenced by currentlyComputingResidual(), FEProblemBase::setCurrentlyComputingResidual(), and setCurrentlyComputingResidual().

_currently_computing_residual_and_jacobian

bool SubProblem::_currently_computing_residual_and_jacobian

protected

Flag to determine whether the problem is currently computing the residual and Jacobian.

Definition at line 1100 of file SubProblem.h.

Referenced by currentlyComputingResidualAndJacobian(), and setCurrentlyComputingResidualAndJacobian().

_default_ghosting

bool SubProblem::_default_ghosting

protected

Whether or not to use default libMesh coupling.

Definition at line 1091 of file SubProblem.h.

Referenced by defaultGhosting().

_dirac_kernel_info

DiracKernelInfo SubProblem::_dirac_kernel_info

protected

Definition at line 1050 of file SubProblem.h.

Referenced by DisplacedProblem::clearDiracInfo(), FEProblemBase::clearDiracInfo(), diracKernelInfo(), DisplacedProblem::getDiracElements(), FEProblemBase::getDiracElements(), FEProblemBase::meshChanged(), DisplacedProblem::reinitDirac(), FEProblemBase::reinitDirac(), DisplacedProblem::updateMesh(), and DisplacedProblem::updateMesh().

_enabled

const bool& MooseObject::_enabled

protectedinherited

Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

Definition at line 71 of file MooseObject.h.

Referenced by MooseObject::enabled().

_factory

Factory& SubProblem::_factory

protected

The Factory for building objects.

Definition at line 1048 of file SubProblem.h.

Referenced by FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addConvergence(), FEProblemBase::addDefaultMultiAppFixedPointConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), MFEMProblem::addDefaultProblemComposer(), MFEMEigenproblem::addDefaultProblemComposer(), FEProblemBase::addDefaultSteadyStateConvergence(), MFEMProblem::addDefaultWeakForm(), MFEMEigenproblem::addDefaultWeakForm(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVGradientMethod(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterpolationMethod(), FEProblemBase::addIndicator(), FEProblemBase::addInitialCondition(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), FEProblemBase::addMultiApp(), FEProblemBase::addObject(), FEProblemBase::addOutput(), FEProblemBase::addPredictor(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), DumpObjectsProblem::deduceNecessaryParameters(), FEProblemBase::getFunction(), and FEProblemBase::getKokkosFunction().

_functor_to_request_info

std::vector<std::multimap<std::string, std::pair<bool, bool> > > SubProblem::_functor_to_request_info

private

A multimap (for each thread) from unfilled functor requests to whether the requests were for AD functors and whether the requestor was an AD object.

Definition at line 1162 of file SubProblem.h.

Referenced by addFunctor(), getFunctor(), and SubProblem().

_functor_to_requestors

std::map<std::string, std::set<std::string> > SubProblem::_functor_to_requestors

private

The requestors of functors where the key is the prop name and the value is a set of names of requestors.

Definition at line 1158 of file SubProblem.h.

Referenced by getFunctor(), initialSetup(), and showFunctorRequestors().

_functors

std::vector<std::multimap<std::string, std::tuple<TrueFunctorIs, std::unique_ptr<Moose::FunctorEnvelopeBase>, std::unique_ptr<Moose::FunctorEnvelopeBase> > > > SubProblem::_functors

private

A container holding pointers to all the functors in our problem.

We hold a tuple where the zeroth item in the tuple is an enumerator that describes what type of functor the "true" functor is (either NONAD or AD), the first item in the tuple is the non-AD version of the functor, and the second item in the tuple is the AD version of the functor

Definition at line 1145 of file SubProblem.h.

Referenced by addFunctor(), getFunctor(), hasFunctor(), hasFunctorWithType(), initialSetup(), showFunctors(), and SubProblem().

_ghosted_elems

std::set<dof_id_type> SubProblem::_ghosted_elems

protected

Elements that should have Dofs ghosted to the local processor.

Definition at line 1094 of file SubProblem.h.

Referenced by FEProblemBase::addGhostedElem(), ghostedElems(), FEProblemBase::meshChanged(), FEProblemBase::possiblyRebuildGeomSearchPatches(), and FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects().

_has_active_elemental_moose_variables

std::vector<unsigned int> SubProblem::_has_active_elemental_moose_variables

protected

Whether or not there is currently a list of active elemental moose variables.

Definition at line 1080 of file SubProblem.h.

Referenced by clearActiveElementalMooseVariables(), hasActiveElementalMooseVariables(), setActiveElementalMooseVariables(), and SubProblem().

_have_ad_objects

bool SubProblem::_have_ad_objects

protected

AD flag indicating whether any AD objects have been added.

Definition at line 1115 of file SubProblem.h.

Referenced by haveADObjects(), haveADObjects(), DisplacedProblem::haveADObjects(), and FEProblemBase::haveADObjects().

_map_block_material_props

std::map<SubdomainID, std::set<std::string> > SubProblem::_map_block_material_props

protected

Map of material properties (block_id -> list of properties)

Definition at line 1053 of file SubProblem.h.

Referenced by checkBlockMatProps(), getMaterialPropertyBlocks(), hasBlockMaterialProperty(), and storeSubdomainMatPropName().

_map_block_material_props_check

std::map<SubdomainID, std::multimap<std::string, std::string> > SubProblem::_map_block_material_props_check

protected

Data structures of the requested material properties.

We store them in a map from boundary/block id to multimap. Each of the multimaps is a list of requestor object names to material property names.

Definition at line 1071 of file SubProblem.h.

Referenced by checkBlockMatProps(), and storeSubdomainDelayedCheckMatProp().

_map_boundary_material_props

std::map<BoundaryID, std::set<std::string> > SubProblem::_map_boundary_material_props

protected

Map for boundary material properties (boundary_id -> list of properties)

Definition at line 1056 of file SubProblem.h.

Referenced by checkBoundaryMatProps(), getMaterialPropertyBoundaryIDs(), hasBoundaryMaterialProperty(), and storeBoundaryMatPropName().

_map_boundary_material_props_check

std::map<BoundaryID, std::multimap<std::string, std::string> > SubProblem::_map_boundary_material_props_check

protected

Definition at line 1072 of file SubProblem.h.

Referenced by checkBoundaryMatProps(), and storeBoundaryDelayedCheckMatProp().

_material_property_requested

std::set<std::string> SubProblem::_material_property_requested

protected

set containing all material property names that have been requested by getMaterialProperty*

Definition at line 1063 of file SubProblem.h.

Referenced by isMatPropRequested(), and markMatPropRequested().

_matrix_tag_id_to_tag_name

std::map<TagID, TagName> SubProblem::_matrix_tag_id_to_tag_name

protected

Reverse map.

Definition at line 1045 of file SubProblem.h.

Referenced by addMatrixTag(), matrixTagExists(), and matrixTagName().

_matrix_tag_name_to_tag_id

std::map<TagName, TagID> SubProblem::_matrix_tag_name_to_tag_id

protected

The currently declared tags.

Definition at line 1042 of file SubProblem.h.

Referenced by addMatrixTag(), getMatrixTagID(), getMatrixTags(), matrixTagExists(), and numMatrixTags().

_name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

Referenced by AddFieldSplitAction::act(), AddBCAction::act(), AddConstraintAction::act(), AddControlAction::act(), AddConvergenceAction::act(), AddCorrectorAction::act(), AddDamperAction::act(), AddDGKernelAction::act(), AddDiracKernelAction::act(), AddDistributionAction::act(), AddFunctionAction::act(), AddFunctorMaterialAction::act(), AddFVBCAction::act(), AddFVGradientMethodAction::act(), AddFVInitialConditionAction::act(), AddFVInterfaceKernelAction::act(), AddFVInterpolationMethodAction::act(), AddFVKernelAction::act(), AddHDGKernelAction::act(), AddIndicatorAction::act(), AddInitialConditionAction::act(), AddInterfaceKernelAction::act(), AddKernelAction::act(), AddLinearFVBCAction::act(), AddLinearFVKernelAction::act(), AddMarkerAction::act(), AddMaterialAction::act(), AddMeshDivisionAction::act(), AddMeshGeneratorAction::act(), AddMeshModifiersAction::act(), AddMultiAppAction::act(), AddNodalKernelAction::act(), AddOutputAction::act(), AddPositionsAction::act(), AddPostprocessorAction::act(), AddReporterAction::act(), AddSamplerAction::act(), AddScalarKernelAction::act(), AddTimesAction::act(), AddTimeStepperAction::act(), AddTransferAction::act(), AddUserObjectAction::act(), AddVectorPostprocessorAction::act(), PartitionerAction::act(), ReadExecutorParamsAction::act(), SetupPreconditionerAction::act(), SetupTimeIntegratorAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), AddMFEMFESpaceAction::act(), AddMFEMFESpaceHierarchyAction::act(), AddMFEMProblemComposerAction::act(), AddMFEMSolverAction::act(), AddMFEMSubMeshAction::act(), AddMFEMWeakFormAction::act(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), PiecewiseLinearBase::buildInterpolation(), CombinerGenerator::CombinerGenerator(), Executor::Executor(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), MultiApp::fillPositions(), CentroidMultiApp::fillPositions(), QuadraturePointMultiApp::fillPositions(), FunctionDT::FunctionDT(), FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MooseBase::MooseBase(), MooseBase::name(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseBase::setData(), and AddVariableAction::varName().

_not_zeroed_tagged_vectors

std::unordered_set<TagID> SubProblem::_not_zeroed_tagged_vectors

protected

the list of vector tags that will not be zeroed when all other tags are

Definition at line 1118 of file SubProblem.h.

Referenced by addNotZeroedVectorTag(), FEProblemBase::restoreSolutions(), and vectorTagNotZeroed().

_parent

const ParallelParamObject& DataFileInterface::_parent

privateinherited

Definition at line 58 of file DataFileInterface.h.

Referenced by DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), and DataFileInterface::getDataFilePath().

_pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 384 of file MooseBase.h.

Referenced by AddAuxKernelAction::act(), AddFVICAction::act(), AddICAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), EigenProblemSolve::initialSetup(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseApp::MooseApp(), MooseBase::MooseBase(), MultiSystemSolveObject::MultiSystemSolveObject(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), MooseBase::queryParam(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

_pbblf_functors

std::vector<std::map<std::string, std::unique_ptr<Moose::FunctorAbstract> > > SubProblem::_pbblf_functors

private

Container to hold PiecewiseByBlockLambdaFunctors.

Definition at line 1148 of file SubProblem.h.

Referenced by addPiecewiseByBlockLambdaFunctor(), customSetup(), jacobianSetup(), residualSetup(), SubProblem(), and timestepSetup().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

_prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_root_alg_gf_to_sys_clones

std::unordered_map<libMesh::GhostingFunctor *, std::vector<std::shared_ptr<libMesh::GhostingFunctor> > > SubProblem::_root_alg_gf_to_sys_clones

private

A map from a root algebraic ghosting functor, e.g.

the ghosting functor passed into removeAlgebraicGhostingFunctor, to its clones in other systems, e.g. systems other than system 0

Definition at line 1196 of file SubProblem.h.

Referenced by cloneAlgebraicGhostingFunctor(), and removeAlgebraicGhostingFunctor().

_root_coupling_gf_to_sys_clones

std::unordered_map<libMesh::GhostingFunctor *, std::vector<std::shared_ptr<libMesh::GhostingFunctor> > > SubProblem::_root_coupling_gf_to_sys_clones

private

A map from a root coupling ghosting functor, e.g.

the ghosting functor passed into removeCouplingGhostingFunctor, to its clones in other systems, e.g. systems other than system 0

Definition at line 1203 of file SubProblem.h.

Referenced by cloneCouplingGhostingFunctor(), and removeCouplingGhostingFunctor().

_safe_access_tagged_matrices

bool SubProblem::_safe_access_tagged_matrices

protected

Is it safe to retrieve data from tagged matrices.

Definition at line 1109 of file SubProblem.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::resetState(), and safeAccessTaggedMatrices().

_safe_access_tagged_vectors

bool SubProblem::_safe_access_tagged_vectors

protected

Is it safe to retrieve data from tagged vectors.

Definition at line 1112 of file SubProblem.h.

Referenced by FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::resetState(), and safeAccessTaggedVectors().

_show_chain_control_data

bool SubProblem::_show_chain_control_data

private

Whether to output a list of all the chain control data.

Definition at line 1168 of file SubProblem.h.

Referenced by initialSetup(), setChainControlDataOutput(), and timestepSetup().

_show_functors

bool SubProblem::_show_functors

private

Whether to output a list of the functors used and requested (currently only at initialSetup)

Definition at line 1165 of file SubProblem.h.

Referenced by initialSetup(), and setFunctorOutput().

_si_moose_base

const MooseBase& SolutionInvalidInterface::_si_moose_base

privateinherited

The MooseBase that owns this interface.

Definition at line 111 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal(), SolutionInvalidInterface::mooseDeprecated(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), SolutionInvalidInterface::paramWarning(), and SolutionInvalidInterface::registerInvalidSolutionInternal().

_si_problem

const FEProblemBase* SolutionInvalidInterface::_si_problem

privateinherited

A pointer to FEProblem base.

Definition at line 114 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

_termination_requested

bool Problem::_termination_requested

protectedinherited

True if termination of the solve has been requested.

Definition at line 58 of file Problem.h.

Referenced by Problem::isSolveTerminationRequested(), and Problem::terminateSolve().

_type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 378 of file MooseBase.h.

Referenced by FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MooseBase::MooseBase(), FEProblemBase::solverTypeString(), and MooseBase::type().

_typed_vector_tags

std::vector<std::vector<VectorTag> > SubProblem::_typed_vector_tags

private

The vector tags associated with each VectorTagType This is kept separate from _vector_tags for quick access into typed vector tags in places where we don't want to build a new vector every call (like in residual evaluation)

Definition at line 1178 of file SubProblem.h.

Referenced by addVectorTag(), getVectorTags(), and verifyVectorTags().

_var_dof_map

std::map<std::string, std::vector<dof_id_type> > SubProblem::_var_dof_map

Definition at line 685 of file SubProblem.h.

Referenced by MooseVariableBase::allDofIndices(), FEProblemBase::setNonlocalCouplingMatrix(), and FEProblemBase::setVariableAllDoFMap().

_vector_tags

std::vector<VectorTag> SubProblem::_vector_tags

private

The declared vector tags.

Definition at line 1171 of file SubProblem.h.

Referenced by addVectorTag(), getVectorTag(), getVectorTags(), vectorTagExists(), vectorTagExists(), vectorTagName(), vectorTagType(), and verifyVectorTags().

_vector_tags_name_map

std::map<TagName, TagID> SubProblem::_vector_tags_name_map

private

Map of vector tag TagName to TagID.

Definition at line 1181 of file SubProblem.h.

Referenced by addVectorTag(), getVectorTagID(), and verifyVectorTags().

_zero_block_material_props

std::map<SubdomainID, std::set<MaterialPropertyName> > SubProblem::_zero_block_material_props

protected

Set of properties returned as zero properties.

Definition at line 1059 of file SubProblem.h.

Referenced by checkBlockMatProps(), FEProblemBase::checkDependMaterialsHelper(), and storeSubdomainZeroMatProp().

_zero_boundary_material_props

std::map<BoundaryID, std::set<MaterialPropertyName> > SubProblem::_zero_boundary_material_props

protected

Definition at line 1060 of file SubProblem.h.

Referenced by checkBoundaryMatProps(), and storeBoundaryZeroMatProp().

app_param

const std::string MooseBase::app_param = "_moose_app"

staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MeshGenerator::addMeshSubgenerator(), InputParameters::callMooseError(), ActionFactory::create(), ActionFactory::getValidParams(), Factory::getValidParams(), AutomaticMortarGeneration::initOutput(), SetupMeshAction::modifyParamsForUseSplit(), and MortarNodalGeometryOutput::validParams().

kokkos_object_param

const std::string MooseBase::kokkos_object_param = "_kokkos_object"

staticinherited

The name of the parameter that indicates an object is a Kokkos functor.

Definition at line 64 of file MooseBase.h.

Referenced by InputParameters::isKokkosObject().

moose_base_param

const std::string MooseBase::moose_base_param = "_moose_base"

staticinherited

The name of the parameter that contains the moose system base.

Definition at line 61 of file MooseBase.h.

Referenced by InputParameters::getBase(), InputParameters::hasBase(), and InputParameters::registerBase().

name_param

const std::string MooseBase::name_param = "_object_name"

staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), AppFactory::create(), InputParameters::getObjectName(), AutomaticMortarGeneration::initOutput(), InputParameters::isMooseBaseObject(), MooseMesh::prepare(), CouplingFunctorCheckAction::validParams(), and MooseBase::validParams().

type_param

const std::string MooseBase::type_param = "_type"

staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

Referenced by ActionFactory::create(), AppFactory::create(), InputParameters::getObjectType(), Factory::initialize(), InputParameters::isMooseBaseObject(), InputParameters::queryObjectType(), MooseBase::validParams(), and MortarNodalGeometryOutput::validParams().

unique_name_param

const std::string MooseBase::unique_name_param = "_unique_name"

staticinherited

The name of the parameter that contains the unique object name.

Definition at line 57 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), AppFactory::create(), InputParameterWarehouse::removeInputParameters(), MooseBase::uniqueName(), and MooseBase::validParams().

usingCombinedWarningSolutionWarnings

MooseObject::usingCombinedWarningSolutionWarnings

inherited

Definition at line 67 of file MooseObject.h.

---

The documentation for this class was generated from the following files:

• include/problems/SubProblem.h
• src/problems/SubProblem.C