MFEMProblem Class Reference

#include <MFEMProblem.h>

Inheritance diagram for MFEMProblem:

Public Types
enum	Direction : unsigned char { Direction::TO_EXTERNAL_APP, Direction::FROM_EXTERNAL_APP }
enum	CoverageCheckMode {   CoverageCheckMode::FALSE, CoverageCheckMode::TRUE, CoverageCheckMode::OFF, CoverageCheckMode::ON,   CoverageCheckMode::SKIP_LIST, CoverageCheckMode::ONLY_LIST }
using	DataFileParameterType = DataFileName
	The parameter type this interface expects for a data file name. More...

Public Member Functions
	MFEMProblem (const InputParameters &params)
virtual	~MFEMProblem ()
virtual void	initialSetup () override
virtual void	externalSolve () override
	New interface for solving an External problem. More...
virtual void	syncSolutions (Direction) override
	Method to transfer data to/from the external application to the associated transfer mesh. More...
virtual MFEMMesh &	mesh () override
	Overwritten mesh() method from base MooseMesh to retrieve the correct mesh type, in this case MFEMMesh. More...
virtual const MFEMMesh &	mesh () const override
virtual std::vector< VariableName >	getAuxVariableNames ()
	Returns all the variable names from the auxiliary system base. More...
void	addBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters &parameters) override
void	addMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters) override
void	addFunctorMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters) override
void	addFESpace (const std::string &user_object_name, const std::string &name, InputParameters &parameters)
	Add an MFEM FESpace to the problem. More...
void	setDevice ()
	Set the device to use to solve the FE problem. More...
void	setMesh ()
	Set the mesh used by MFEM. More...
void	addSubMesh (const std::string &user_object_name, const std::string &name, InputParameters &parameters)
	Add an MFEM SubMesh to the problem. More...
void	addTransfer (const std::string &transfer_name, const std::string &name, InputParameters &parameters) override
	Add transfers between MultiApps and/or MFEM SubMeshes. More...
void	addVariable (const std::string &var_type, const std::string &var_name, InputParameters &parameters) override
	Override of ExternalProblem::addVariable. More...
void	addGridFunction (const std::string &var_type, const std::string &var_name, InputParameters &parameters)
	Adds one MFEM GridFunction to be used in the MFEM solve. More...
void	addAuxVariable (const std::string &var_type, const std::string &var_name, InputParameters &parameters) override
	Override of ExternalProblem::addAuxVariable. More...
void	addKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters) override
	Override of ExternalProblem::addKernel. More...
void	addAuxKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters) override
	Override of ExternalProblem::addAuxKernel. More...
void	addFunction (const std::string &type, const std::string &name, InputParameters &parameters) override
	Override of ExternalProblem::addFunction. More...
void	addInitialCondition (const std::string &ic_name, const std::string &name, InputParameters &parameters) override
void	addPostprocessor (const std::string &type, const std::string &name, InputParameters &parameters) override
	Override of ExternalProblem::addPostprocessor. More...
void	addMFEMPreconditioner (const std::string &user_object_name, const std::string &name, InputParameters &parameters)
	Method called in AddMFEMPreconditionerAction which will create the solver. More...
void	addMFEMSolver (const std::string &user_object_name, const std::string &name, InputParameters &parameters)
	Method called in AddMFEMSolverAction which will create the solver. More...
void	addMFEMNonlinearSolver ()
	Add the nonlinear solver to the system. More...
InputParameters	addMFEMFESpaceFromMOOSEVariable (InputParameters &moosevar_params)
	Method used to get an mfem FEC depending on the variable family specified in the input file. More...
Moose::MFEM::CoefficientManager &	getCoefficients ()
	Method to get the PropertyManager object for storing material properties and converting them to MFEM coefficients. More...
MFEMProblemData &	getProblemData ()
	Method to get the current MFEMProblemData object storing the current data specifying the FE problem. More...
MPI_Comm	getComm ()
	Return the MPI communicator associated with this FE problem's mesh. More...
void	displaceMesh ()
	Displace the mesh, if mesh displacement is enabled. More...
std::optional< std::reference_wrapper< mfem::ParGridFunction const > >	getMeshDisplacementGridFunction ()
	Returns optional reference to the displacement GridFunction to apply to nodes. More...
Moose::FEBackend	feBackend () const override
std::string	solverTypeString (unsigned int solver_sys_num) override
	Return solver type as a human readable string. More...
std::shared_ptr< mfem::ParGridFunction >	getGridFunction (const std::string &name)
virtual void	solve (unsigned int nl_sys_num=0) override final
	Solve is implemented to providing syncing to/from the "transfer" mesh. More...
virtual void	addExternalVariables ()
	Method called to add AuxVariables to the simulation. More...
virtual libMesh::EquationSystems &	es () override
const MooseMesh &	mesh (bool use_displaced) const override
void	setCoordSystem (const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)
void	setAxisymmetricCoordAxis (const MooseEnum &rz_coord_axis)
void	setCoupling (Moose::CouplingType type)
	Set the coupling between variables TODO: allow user-defined coupling. More...
Moose::CouplingType	coupling () const
void	setCouplingMatrix (std::unique_ptr< libMesh::CouplingMatrix > cm, const unsigned int nl_sys_num)
	Set custom coupling matrix. More...
void	setCouplingMatrix (libMesh::CouplingMatrix *cm, const unsigned int nl_sys_num)
const libMesh::CouplingMatrix *	couplingMatrix (const unsigned int nl_sys_num) const override
	The coupling matrix defining what blocks exist in the preconditioning matrix. More...
void	setNonlocalCouplingMatrix ()
	Set custom coupling matrix for variables requiring nonlocal contribution. More...
bool	areCoupled (const unsigned int ivar, const unsigned int jvar, const unsigned int nl_sys_num) const
bool	hasUOAuxStateCheck () const
	Whether or not MOOSE will perform a user object/auxiliary kernel state check. More...
bool	checkingUOAuxState () const
	Return a flag to indicate whether we are executing user objects and auxliary kernels for state check Note: This function can return true only when hasUOAuxStateCheck() returns true, i.e. More...
void	trustUserCouplingMatrix ()
	Whether to trust the user coupling matrix even if we want to do things like be paranoid and create a full coupling matrix. More...
std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > &	couplingEntries (const THREAD_ID tid, const unsigned int nl_sys_num)
std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > &	nonlocalCouplingEntries (const THREAD_ID tid, const unsigned int nl_sys_num)
virtual bool	hasVariable (const std::string &var_name) const override
	Whether or not this problem has the variable. More...
bool	hasSolverVariable (const std::string &var_name) const
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 override
	Returns the variable reference for requested variable which must be of the expected_var_type (Nonlinear vs. More...
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. More...
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 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)
MooseVariableFieldBase &	getActualFieldVariable (const THREAD_ID tid, const std::string &var_name) override
	Returns the variable reference for requested MooseVariableField which may be in any system. More...
virtual MooseVariable &	getStandardVariable (const THREAD_ID tid, const std::string &var_name) override
	Returns the variable reference for requested MooseVariable which may be in any system. More...
virtual VectorMooseVariable &	getVectorVariable (const THREAD_ID tid, const std::string &var_name) override
	Returns the variable reference for requested VectorMooseVariable which may be in any system. More...
virtual ArrayMooseVariable &	getArrayVariable (const THREAD_ID tid, const std::string &var_name) override
	Returns the variable reference for requested ArrayMooseVariable which may be in any system. More...
virtual bool	hasScalarVariable (const std::string &var_name) const override
	Returns a Boolean indicating whether any system contains a variable with the name provided. More...
virtual MooseVariableScalar &	getScalarVariable (const THREAD_ID tid, const std::string &var_name) override
	Returns the scalar variable reference from whichever system contains it. More...
virtual libMesh::System &	getSystem (const std::string &var_name) override
	Returns the equation system containing the variable provided. More...
const RestartableEquationSystems &	getRestartableEquationSystems () const
	Get the RestartableEquationSystems object. More...
virtual void	setActiveElementalMooseVariables (const std::set< MooseVariableFEBase *> &moose_vars, const THREAD_ID tid) override
	Set the MOOSE variables to be reinited on each element. More...
virtual void	clearActiveElementalMooseVariables (const THREAD_ID tid) override
	Clear the active elemental MooseVariableFEBase. More...
virtual void	clearActiveFEVariableCoupleableMatrixTags (const THREAD_ID tid) override
virtual void	clearActiveFEVariableCoupleableVectorTags (const THREAD_ID tid) override
virtual void	setActiveFEVariableCoupleableVectorTags (std::set< TagID > &vtags, const THREAD_ID tid) override
virtual void	setActiveFEVariableCoupleableMatrixTags (std::set< TagID > &mtags, const THREAD_ID tid) override
virtual void	clearActiveScalarVariableCoupleableMatrixTags (const THREAD_ID tid) override
virtual void	clearActiveScalarVariableCoupleableVectorTags (const THREAD_ID tid) override
virtual void	setActiveScalarVariableCoupleableVectorTags (std::set< TagID > &vtags, const THREAD_ID tid) override
virtual void	setActiveScalarVariableCoupleableMatrixTags (std::set< TagID > &mtags, const THREAD_ID tid) override
virtual void	createQRules (libMesh::QuadratureType type, libMesh::Order order, libMesh::Order volume_order=libMesh::INVALID_ORDER, libMesh::Order face_order=libMesh::INVALID_ORDER, SubdomainID block=Moose::ANY_BLOCK_ID, bool allow_negative_qweights=true)
void	bumpVolumeQRuleOrder (libMesh::Order order, SubdomainID block)
	Increases the element/volume quadrature order for the specified mesh block if and only if the current volume quadrature order is lower. More...
void	bumpAllQRuleOrder (libMesh::Order order, SubdomainID block)
unsigned int	getMaxQps () const
libMesh::Order	getMaxScalarOrder () const
void	checkNonlocalCoupling ()
void	checkUserObjectJacobianRequirement (THREAD_ID tid)
void	setVariableAllDoFMap (const std::vector< const MooseVariableFEBase *> &moose_vars)
const std::vector< const MooseVariableFEBase * > &	getUserObjectJacobianVariables (const THREAD_ID tid) const
virtual Assembly &	assembly (const THREAD_ID tid, const unsigned int sys_num) override
virtual const Assembly &	assembly (const THREAD_ID tid, const unsigned int sys_num) const override
Moose::Kokkos::Assembly &	kokkosAssembly ()
const Moose::Kokkos::Assembly &	kokkosAssembly () const
virtual std::vector< VariableName >	getVariableNames ()
	Returns a list of all the variables in the problem (both from the NL and Aux systems. More...
void	checkDuplicatePostprocessorVariableNames ()
void	timestepSetup () override
void	customSetup (const ExecFlagType &exec_type) override
void	residualSetup () override
void	jacobianSetup () override
virtual void	prepare (const Elem *elem, const THREAD_ID tid) override
virtual void	prepare (const Elem *elem, unsigned int ivar, unsigned int jvar, const std::vector< dof_id_type > &dof_indices, const THREAD_ID tid) override
virtual void	prepareFace (const Elem *elem, const THREAD_ID tid) override
virtual void	setCurrentSubdomainID (const Elem *elem, const THREAD_ID tid) override
virtual void	setNeighborSubdomainID (const Elem *elem, unsigned int side, const THREAD_ID tid) override
virtual void	setNeighborSubdomainID (const Elem *elem, const THREAD_ID tid)
virtual void	prepareAssembly (const THREAD_ID tid) override
virtual void	addGhostedElem (dof_id_type elem_id) override
	Will make sure that all dofs connected to elem_id are ghosted to this processor. More...
virtual void	addGhostedBoundary (BoundaryID boundary_id) override
	Will make sure that all necessary elements from boundary_id are ghosted to this processor. More...
virtual void	ghostGhostedBoundaries () override
	Causes the boundaries added using addGhostedBoundary to actually be ghosted. More...
virtual void	sizeZeroes (unsigned int size, const THREAD_ID tid)
virtual bool	reinitDirac (const Elem *elem, const THREAD_ID tid) override
	Returns true if the Problem has Dirac kernels it needs to compute on elem. More...
virtual void	reinitElem (const Elem *elem, const THREAD_ID tid) override
virtual void	reinitElemPhys (const Elem *elem, const std::vector< Point > &phys_points_in_elem, const THREAD_ID tid) override
void	reinitElemFace (const Elem *elem, unsigned int side, BoundaryID, const THREAD_ID tid)
virtual void	reinitElemFace (const Elem *elem, unsigned int side, const THREAD_ID tid) override
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) override
virtual void	reinitNode (const Node *node, const THREAD_ID tid) override
virtual void	reinitNodeFace (const Node *node, BoundaryID bnd_id, const THREAD_ID tid) override
virtual void	reinitNodes (const std::vector< dof_id_type > &nodes, const THREAD_ID tid) override
virtual void	reinitNodesNeighbor (const std::vector< dof_id_type > &nodes, const THREAD_ID tid) override
virtual void	reinitNeighbor (const Elem *elem, unsigned int side, const THREAD_ID tid) override
virtual void	reinitNeighborPhys (const Elem *neighbor, unsigned int neighbor_side, const std::vector< Point > &physical_points, const THREAD_ID tid) override
virtual void	reinitNeighborPhys (const Elem *neighbor, const std::vector< Point > &physical_points, const THREAD_ID tid) override
virtual void	reinitElemNeighborAndLowerD (const Elem *elem, unsigned int side, const THREAD_ID tid) override
virtual void	reinitScalars (const THREAD_ID tid, bool reinit_for_derivative_reordering=false) override
	fills the VariableValue arrays for scalar variables from the solution vector More...
virtual void	reinitOffDiagScalars (const THREAD_ID tid) override
virtual void	getDiracElements (std::set< const Elem *> &elems) override
	Fills "elems" with the elements that should be looped over for Dirac Kernels. More...
virtual void	clearDiracInfo () override
	Gets called before Dirac Kernels are asked to add the points they are supposed to be evaluated in. More...
virtual void	subdomainSetup (SubdomainID subdomain, const THREAD_ID tid)
virtual void	neighborSubdomainSetup (SubdomainID subdomain, const THREAD_ID tid)
virtual void	newAssemblyArray (std::vector< std::shared_ptr< SolverSystem >> &solver_systems)
virtual void	initNullSpaceVectors (const InputParameters &parameters, std::vector< std::shared_ptr< NonlinearSystemBase >> &nl)
virtual void	init () override
void	initKokkos ()
	Construct Kokkos assembly and systems and allocate Kokkos material property storages. More...
virtual void	solveLinearSystem (const unsigned int linear_sys_num, const Moose::PetscSupport::PetscOptions *po=nullptr)
	Build and solve a linear system. More...
virtual void	setException (const std::string &message)
	Set an exception, which is stored at this point by toggling a member variable in this class, and which must be followed up with by a call to checkExceptionAndStopSolve(). More...
virtual bool	hasException ()
	Whether or not an exception has occurred. More...
virtual void	checkExceptionAndStopSolve (bool print_message=true)
	Check to see if an exception has occurred on any processor and, if possible, force the solve to fail, which will result in the time step being cut. More...
virtual bool	solverSystemConverged (const unsigned int solver_sys_num) override
virtual unsigned int	nNonlinearIterations (const unsigned int nl_sys_num) const override
virtual unsigned int	nLinearIterations (const unsigned int nl_sys_num) const override
virtual Real	finalNonlinearResidual (const unsigned int nl_sys_num) const override
virtual bool	computingPreSMOResidual (const unsigned int nl_sys_num) const override
	Returns true if the problem is in the process of computing it's initial residual. More...
virtual bool	startedInitialSetup ()
	Returns true if we are in or beyond the initialSetup stage. More...
virtual void	onTimestepBegin () override
virtual void	onTimestepEnd () override
virtual Real &	time () const
virtual Real &	timeOld () const
virtual int &	timeStep () const
virtual Real &	dt () const
virtual Real &	dtOld () const
Real	getTimeFromStateArg (const Moose::StateArg &state) const
	Returns the time associated with the requested state. More...
virtual void	transient (bool trans)
virtual bool	isTransient () const override
virtual void	addTimeIntegrator (const std::string &type, const std::string &name, InputParameters &parameters)
virtual void	addPredictor (const std::string &type, const std::string &name, InputParameters &parameters)
virtual void	copySolutionsBackwards ()
virtual void	advanceState ()
	Advance all of the state holding vectors / datastructures so that we can move to the next timestep. More...
virtual void	restoreSolutions ()
virtual void	saveOldSolutions ()
	Allocate vectors and save old solutions into them. More...
virtual void	restoreOldSolutions ()
	Restore old solutions from the backup vectors and deallocate them. More...
void	needSolutionState (unsigned int oldest_needed, Moose::SolutionIterationType iteration_type)
	Declare that we need up to old (1) or older (2) solution states for a given type of iteration. More...
virtual void	outputStep (ExecFlagType type)
	Output the current step. More...
virtual void	postExecute ()
	Method called at the end of the simulation. More...
void	forceOutput ()
	Indicates that the next call to outputStep should be forced. More...
virtual void	initPetscOutputAndSomeSolverSettings ()
	Reinitialize PETSc output for proper linear/nonlinear iteration display. More...
Moose::PetscSupport::PetscOptions &	getPetscOptions ()
	Retrieve a writable reference the PETSc options (used by PetscSupport) More...
void	logAdd (const std::string &system, const std::string &name, const std::string &type, const InputParameters &params) const
	Output information about the object just added to the problem. More...
virtual bool	hasFunction (const std::string &name, const THREAD_ID tid=0)
virtual Function &	getFunction (const std::string &name, const THREAD_ID tid=0)
virtual void	addMeshDivision (const std::string &type, const std::string &name, InputParameters &params)
	Add a MeshDivision. More...
MeshDivision &	getMeshDivision (const std::string &name, const THREAD_ID tid=0) const
	Get a MeshDivision. More...
virtual void	addConvergence (const std::string &type, const std::string &name, InputParameters &parameters)
	Adds a Convergence object. More...
virtual Convergence &	getConvergence (const std::string &name, const THREAD_ID tid=0) const
	Gets a Convergence object. More...
virtual const std::vector< std::shared_ptr< Convergence > > &	getConvergenceObjects (const THREAD_ID tid=0) const
	Gets the Convergence objects. More...
virtual bool	hasConvergence (const std::string &name, const THREAD_ID tid=0) const
	Returns true if the problem has a Convergence object of the given name. More...
bool	needToAddDefaultNonlinearConvergence () const
	Returns true if the problem needs to add the default nonlinear convergence. More...
bool	needToAddDefaultMultiAppFixedPointConvergence () const
	Returns true if the problem needs to add the default fixed point convergence. More...
bool	needToAddDefaultSteadyStateConvergence () const
	Returns true if the problem needs to add the default steady-state detection convergence. More...
void	setNeedToAddDefaultNonlinearConvergence ()
	Sets _need_to_add_default_nonlinear_convergence to true. More...
void	setNeedToAddDefaultMultiAppFixedPointConvergence ()
	Sets _need_to_add_default_multiapp_fixed_point_convergence to true. More...
void	setNeedToAddDefaultSteadyStateConvergence ()
	Sets _need_to_add_default_steady_state_convergence to true. More...
bool	hasSetMultiAppFixedPointConvergenceName () const
	Returns true if the problem has set the fixed point convergence name. More...
bool	hasSetSteadyStateConvergenceName () const
	Returns true if the problem has set the steady-state detection convergence name. More...
virtual void	addDefaultNonlinearConvergence (const InputParameters &params)
	Adds the default nonlinear Convergence associated with the problem. More...
virtual bool	onlyAllowDefaultNonlinearConvergence () const
	Returns true if an error will result if the user supplies 'nonlinear_convergence'. More...
void	addDefaultMultiAppFixedPointConvergence (const InputParameters &params)
	Adds the default fixed point Convergence associated with the problem. More...
void	addDefaultSteadyStateConvergence (const InputParameters &params)
	Adds the default steady-state detection Convergence. More...
virtual void	addLineSearch (const InputParameters &)
	add a MOOSE line search More...
virtual void	lineSearch ()
	execute MOOSE line search More...
LineSearch *	getLineSearch () override
	getter for the MOOSE line search More...
virtual void	addDistribution (const std::string &type, const std::string &name, InputParameters &parameters)
	The following functions will enable MOOSE to have the capability to import distributions. More...
virtual Distribution &	getDistribution (const std::string &name)
virtual void	addSampler (const std::string &type, const std::string &name, InputParameters &parameters)
	The following functions will enable MOOSE to have the capability to import Samplers. More...
virtual Sampler &	getSampler (const std::string &name, const THREAD_ID tid=0)
NonlinearSystemBase &	getNonlinearSystemBase (const unsigned int sys_num)
const NonlinearSystemBase &	getNonlinearSystemBase (const unsigned int sys_num) const
void	setCurrentNonlinearSystem (const unsigned int nl_sys_num)
NonlinearSystemBase &	currentNonlinearSystem ()
const NonlinearSystemBase &	currentNonlinearSystem () const
virtual const SystemBase &	systemBaseNonlinear (const unsigned int sys_num) const override
	Return the nonlinear system object as a base class reference given the system number. More...
virtual SystemBase &	systemBaseNonlinear (const unsigned int sys_num) override
virtual const SystemBase &	systemBaseSolver (const unsigned int sys_num) const override
	Return the solver system object as a base class reference given the system number. More...
virtual SystemBase &	systemBaseSolver (const unsigned int sys_num) override
virtual const SystemBase &	systemBaseAuxiliary () const override
	Return the auxiliary system object as a base class reference. More...
virtual SystemBase &	systemBaseAuxiliary () override
virtual NonlinearSystem &	getNonlinearSystem (const unsigned int sys_num)
Moose::Kokkos::Array< Moose::Kokkos::System > &	getKokkosSystems ()
	Get all Kokkos systems that are associated with MOOSE nonlinear and auxiliary systems. More...
const Moose::Kokkos::Array< Moose::Kokkos::System > &	getKokkosSystems () const
Moose::Kokkos::System &	getKokkosSystem (const unsigned int sys_num)
	Get the Kokkos system of a specified number that is associated with MOOSE nonlinear and auxiliary systems. More...
const Moose::Kokkos::System &	getKokkosSystem (const unsigned int sys_num) const
virtual const SystemBase &	getSystemBase (const unsigned int sys_num) const
	Get constant reference to a system in this problem. More...
virtual SystemBase &	getSystemBase (const unsigned int sys_num)
	Get non-constant reference to a system in this problem. More...
SystemBase &	getSystemBase (const std::string &sys_name)
	Get non-constant reference to a system in this problem. More...
LinearSystem &	getLinearSystem (unsigned int sys_num)
	Get non-constant reference to a linear system. More...
const LinearSystem &	getLinearSystem (unsigned int sys_num) const
	Get a constant reference to a linear system. More...
SolverSystem &	getSolverSystem (unsigned int sys_num)
	Get non-constant reference to a solver system. More...
const SolverSystem &	getSolverSystem (unsigned int sys_num) const
	Get a constant reference to a solver system. More...
void	setCurrentLinearSystem (unsigned int sys_num)
	Set the current linear system pointer. More...
LinearSystem &	currentLinearSystem ()
	Get a non-constant reference to the current linear system. More...
const LinearSystem &	currentLinearSystem () const
	Get a constant reference to the current linear system. More...
virtual const SystemBase &	systemBaseLinear (unsigned int sys_num) const override
	Get a constant base class reference to a linear system. More...
virtual SystemBase &	systemBaseLinear (unsigned int sys_num) override
	Get a non-constant base class reference to a linear system. More...
virtual void	addHDGKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addNodalKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosNodalKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters &parameters)
virtual void	addConstraint (const std::string &c_name, const std::string &name, InputParameters &parameters)
virtual void	setInputParametersFEProblem (InputParameters &parameters)
virtual void	addAuxVariable (const std::string &var_name, const libMesh::FEType &type, const std::set< SubdomainID > *const active_subdomains=NULL)
virtual void	addAuxArrayVariable (const std::string &var_name, const libMesh::FEType &type, unsigned int components, const std::set< SubdomainID > *const active_subdomains=NULL)
virtual void	addAuxScalarVariable (const std::string &var_name, libMesh::Order order, Real scale_factor=1., const std::set< SubdomainID > *const active_subdomains=NULL)
virtual void	addAuxScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosAuxKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
AuxiliarySystem &	getAuxiliarySystem ()
virtual void	addDiracKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addDGKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addFVKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addLinearFVKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addFVBC (const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
virtual void	addLinearFVBC (const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
virtual void	addFVInterfaceKernel (const std::string &fv_ik_name, const std::string &name, InputParameters &parameters)
virtual void	addInterfaceKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addFVInitialCondition (const std::string &ic_name, const std::string &name, InputParameters &parameters)
	Add an initial condition for a finite volume variables. More...
void	projectSolution ()
unsigned short	getCurrentICState ()
	Retrieves the current initial condition state. More...
void	projectInitialConditionOnCustomRange (libMesh::ConstElemRange &elem_range, ConstBndNodeRange &bnd_node_range, const std::optional< std::set< VariableName >> &target_vars=std::nullopt)
	Project initial conditions for custom elem_range and bnd_node_range This is needed when elements/boundary nodes are added to a specific subdomain at an intermediate step. More...
void	projectFunctionOnCustomRange (ConstElemRange &elem_range, Number(*func)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), Gradient(*func_grad)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), const libMesh::Parameters &params, const VariableName &target_var)
	Project a function onto a range of elements for a given variable. More...
virtual void	addMaterialHelper (std::vector< MaterialWarehouse *> warehouse, const std::string &material_name, const std::string &name, InputParameters &parameters)
virtual void	addInterfaceMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters)
void	prepareMaterials (const std::unordered_set< unsigned int > &consumer_needed_mat_props, const SubdomainID blk_id, const THREAD_ID tid)
	Add the MooseVariables and the material properties that the current materials depend on to the dependency list. More...
void	reinitMaterials (SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true)
void	reinitMaterialsFace (SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
	reinit materials on element faces More...
void	reinitMaterialsFaceOnBoundary (const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase *> *const reinit_mats=nullptr)
	reinit materials on element faces on a boundary (internal or external) This specific routine helps us not reinit when don't need to More...
void	reinitMaterialsNeighborOnBoundary (const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase *> *const reinit_mats=nullptr)
	reinit materials on neighbor element (usually faces) on a boundary (internal or external) This specific routine helps us not reinit when don't need to More...
void	reinitMaterialsNeighbor (SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
	reinit materials on the neighboring element face More...
void	reinitMaterialsBoundary (BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase *> *reinit_mats=nullptr)
	reinit materials on a boundary More...
void	reinitMaterialsInterface (BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true)
void	prepareKokkosMaterials (const std::unordered_set< unsigned int > &consumer_needed_mat_props)
void	reinitKokkosMaterials ()
virtual void	swapBackMaterials (const THREAD_ID tid)
virtual void	swapBackMaterialsFace (const THREAD_ID tid)
virtual void	swapBackMaterialsNeighbor (const THREAD_ID tid)
void	setActiveMaterialProperties (const std::unordered_set< unsigned int > &mat_prop_ids, const THREAD_ID tid)
	Record and set the material properties required by the current computing thread. More...
bool	hasActiveMaterialProperties (const THREAD_ID tid) const
	Method to check whether or not a list of active material roperties has been set. More...
void	clearActiveMaterialProperties (const THREAD_ID tid)
	Clear the active material properties. More...
template<typename T >
std::vector< std::shared_ptr< T > >	addObject (const std::string &type, const std::string &name, InputParameters &parameters, const bool threaded=true, const std::string &var_param_name="variable")
	Method for creating and adding an object to the warehouse. More...
virtual void	addVectorPostprocessor (const std::string &pp_name, const std::string &name, InputParameters &parameters)
virtual void	addReporter (const std::string &type, const std::string &name, InputParameters &parameters)
	Add a Reporter object to the simulation. More...
const ReporterData &	getReporterData () const
	Provides const access the ReporterData object. More...
ReporterData &	getReporterData (ReporterData::WriteKey)
	Provides non-const access the ReporterData object that is used to store reporter values. More...
virtual std::vector< std::shared_ptr< UserObject > >	addUserObject (const std::string &user_object_name, const std::string &name, InputParameters &parameters)
const ExecuteMooseObjectWarehouse< UserObject > &	getUserObjects () const
template<class T >
T &	getUserObject (const std::string &name, unsigned int tid=0) const
	Get the user object by its name. More...
const UserObject &	getUserObjectBase (const std::string &name, const THREAD_ID tid=0) const
	Get the user object by its name. More...
const Positions &	getPositionsObject (const std::string &name) const
	Get the Positions object by its name. More...
bool	hasUserObject (const std::string &name) const
	Check if there if a user object of given name. More...
bool	hasPostprocessorValueByName (const PostprocessorName &name) const
	Whether or not a Postprocessor value exists by a given name. More...
const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name, std::size_t t_index=0) const
	Get a read-only reference to the value associated with a Postprocessor that exists. More...
void	setPostprocessorValueByName (const PostprocessorName &name, const PostprocessorValue &value, std::size_t t_index=0)
	Set the value of a PostprocessorValue. More...
bool	hasPostprocessor (const std::string &name) const
	Deprecated. More...
const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const std::string &object_name, const std::string &vector_name, std::size_t t_index=0) const
	Get a read-only reference to the vector value associated with the VectorPostprocessor. More...
void	setVectorPostprocessorValueByName (const std::string &object_name, const std::string &vector_name, const VectorPostprocessorValue &value, std::size_t t_index=0)
	Set the value of a VectorPostprocessor vector. More...
const VectorPostprocessor &	getVectorPostprocessorObjectByName (const std::string &object_name, const THREAD_ID tid=0) const
	Return the VPP object given the name. More...
virtual void	addDamper (const std::string &damper_name, const std::string &name, InputParameters &parameters)
void	setupDampers ()
bool	hasDampers ()
	Whether or not this system has dampers. More...
virtual void	addIndicator (const std::string &indicator_name, const std::string &name, InputParameters &parameters)
virtual void	addMarker (const std::string &marker_name, const std::string &name, InputParameters &parameters)
virtual void	addMultiApp (const std::string &multi_app_name, const std::string &name, InputParameters &parameters)
	Add a MultiApp to the problem. More...
std::shared_ptr< MultiApp >	getMultiApp (const std::string &multi_app_name) const
	Get a MultiApp object by name. More...
std::vector< std::shared_ptr< Transfer > >	getTransfers (ExecFlagType type, Transfer::DIRECTION direction) const
	Get Transfers by ExecFlagType and direction. More...
std::vector< std::shared_ptr< Transfer > >	getTransfers (Transfer::DIRECTION direction) const
const ExecuteMooseObjectWarehouse< Transfer > &	getMultiAppTransferWarehouse (Transfer::DIRECTION direction) const
	Return the complete warehouse for MultiAppTransfer object for the given direction. More...
void	execMultiAppTransfers (ExecFlagType type, Transfer::DIRECTION direction)
	Execute MultiAppTransfers associated with execution flag and direction. More...
bool	execMultiApps (ExecFlagType type, bool auto_advance=true)
	Execute the MultiApps associated with the ExecFlagType. More...
void	finalizeMultiApps ()
void	incrementMultiAppTStep (ExecFlagType type)
	Advance the MultiApps t_step (incrementStepOrReject) associated with the ExecFlagType. More...
void	advanceMultiApps (ExecFlagType type)
	Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep depending on your purpose. More...
void	finishMultiAppStep (ExecFlagType type, bool recurse_through_multiapp_levels=false)
	Finish the MultiApp time step (endStep, postStep) associated with the ExecFlagType. More...
void	backupMultiApps (ExecFlagType type)
	Backup the MultiApps associated with the ExecFlagType. More...
void	restoreMultiApps (ExecFlagType type, bool force=false)
	Restore the MultiApps associated with the ExecFlagType. More...
Real	computeMultiAppsDT (ExecFlagType type)
	Find the smallest timestep over all MultiApps. More...
void	execTransfers (ExecFlagType type)
	Execute the Transfers associated with the ExecFlagType. More...
Real	computeResidualL2Norm (NonlinearSystemBase &sys)
	Computes the residual of a nonlinear system using whatever is sitting in the current solution vector then returns the L2 norm. More...
Real	computeResidualL2Norm (LinearSystem &sys)
	Computes the residual of a linear system using whatever is sitting in the current solution vector then returns the L2 norm. More...
virtual Real	computeResidualL2Norm ()
	Computes the residual using whatever is sitting in the current solution vector then returns the L2 norm. More...
virtual void	computeResidualSys (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)
	This function is called by Libmesh to form a residual. More...
void	computeResidual (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual)
	This function is called by Libmesh to form a residual. More...
virtual void	computeResidual (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, const unsigned int nl_sys_num)
	Form a residual with default tags (nontime, time, residual). More...
void	computeResidualAndJacobian (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, libMesh::SparseMatrix< libMesh::Number > &jacobian)
	Form a residual and Jacobian with default tags. More...
virtual void	computeResidualTag (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, TagID tag)
	Form a residual vector for a given tag. More...
virtual void	computeResidualType (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, TagID tag)
	Form a residual vector for a given tag and "residual" tag. More...
virtual void	computeResidualInternal (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, const std::set< TagID > &tags)
	Form a residual vector for a set of tags. More...
virtual void	computeResidualTags (const std::set< TagID > &tags)
	Form multiple residual vectors and each is associated with one tag. More...
virtual void	computeJacobianSys (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian)
	Form a Jacobian matrix. More...
virtual void	computeJacobian (const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, const unsigned int nl_sys_num)
	Form a Jacobian matrix with the default tag (system). More...
virtual void	computeJacobianTag (const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, TagID tag)
	Form a Jacobian matrix for a given tag. More...
virtual void	computeJacobianInternal (const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, const std::set< TagID > &tags)
	Form a Jacobian matrix for multiple tags. More...
virtual void	computeJacobianTags (const std::set< TagID > &tags)
	Form multiple matrices, and each is associated with a tag. More...
virtual void	computeJacobianBlocks (std::vector< JacobianBlock *> &blocks, const unsigned int nl_sys_num)
	Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditioning matrices. More...
virtual void	computeJacobianBlock (libMesh::SparseMatrix< libMesh::Number > &jacobian, libMesh::System &precond_system, unsigned int ivar, unsigned int jvar)
	Really not a good idea to use this. More...
virtual void	computeLinearSystemSys (libMesh::LinearImplicitSystem &sys, libMesh::SparseMatrix< libMesh::Number > &system_matrix, NumericVector< libMesh::Number > &rhs, const bool compute_gradients=true)
	Assemble both the right hand side and the system matrix of a given linear system. More...
void	computeLinearSystemTags (const NumericVector< libMesh::Number > &soln, const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags, const bool compute_gradients=true)
	Assemble the current linear system given a set of vector and matrix tags. More...
virtual Real	computeDamping (const NumericVector< libMesh::Number > &soln, const NumericVector< libMesh::Number > &update)
virtual bool	shouldUpdateSolution ()
	Check to see whether the problem should update the solution. More...
virtual bool	updateSolution (NumericVector< libMesh::Number > &vec_solution, NumericVector< libMesh::Number > &ghosted_solution)
	Update the solution. More...
virtual void	predictorCleanup (NumericVector< libMesh::Number > &ghosted_solution)
	Perform cleanup tasks after application of predictor to solution vector. More...
virtual void	computeBounds (libMesh::NonlinearImplicitSystem &sys, NumericVector< libMesh::Number > &lower, NumericVector< libMesh::Number > &upper)
virtual void	computeNearNullSpace (libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
virtual void	computeNullSpace (libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
virtual void	computeTransposeNullSpace (libMesh::NonlinearImplicitSystem &sys, std::vector< NumericVector< libMesh::Number > *> &sp)
virtual void	computePostCheck (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &old_soln, NumericVector< libMesh::Number > &search_direction, NumericVector< libMesh::Number > &new_soln, bool &changed_search_direction, bool &changed_new_soln)
virtual void	computeIndicatorsAndMarkers ()
virtual void	computeIndicators ()
virtual void	computeMarkers ()
virtual void	addResidual (const THREAD_ID tid) override
virtual void	addResidualNeighbor (const THREAD_ID tid) override
virtual void	addResidualLower (const THREAD_ID tid) override
virtual void	addResidualScalar (const THREAD_ID tid=0)
virtual void	cacheResidual (const THREAD_ID tid) override
virtual void	cacheResidualNeighbor (const THREAD_ID tid) override
virtual void	addCachedResidual (const THREAD_ID tid) override
virtual void	addCachedResidualDirectly (NumericVector< libMesh::Number > &residual, const THREAD_ID tid)
	Allows for all the residual contributions that are currently cached to be added directly into the vector passed in. More...
virtual void	setResidual (NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
virtual void	setResidual (libMesh::NumericVector< libMesh::Number > &residual, const THREAD_ID tid)=0
virtual void	setResidualNeighbor (NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
virtual void	setResidualNeighbor (libMesh::NumericVector< libMesh::Number > &residual, const THREAD_ID tid)=0
virtual void	addJacobian (const THREAD_ID tid) override
virtual void	addJacobianNeighbor (const THREAD_ID tid) override
virtual void	addJacobianNeighbor (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const 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) override
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	addJacobianNeighborLowerD (const THREAD_ID tid) override
virtual void	addJacobianLowerD (const THREAD_ID tid) override
virtual void	addJacobianBlockTags (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices, const std::set< TagID > &tags, const THREAD_ID tid)
virtual void	addJacobianScalar (const THREAD_ID tid=0)
virtual void	addJacobianOffDiagScalar (unsigned int ivar, const THREAD_ID tid=0)
virtual void	cacheJacobian (const THREAD_ID tid) override
virtual void	cacheJacobianNeighbor (const THREAD_ID tid) override
virtual void	addCachedJacobian (const THREAD_ID tid) override
virtual void	prepareShapes (unsigned int var, const THREAD_ID tid) override
virtual void	prepareFaceShapes (unsigned int var, const THREAD_ID tid) override
virtual void	prepareNeighborShapes (unsigned int var, const THREAD_ID tid) override
virtual void	addDisplacedProblem (std::shared_ptr< DisplacedProblem > displaced_problem)
virtual std::shared_ptr< const DisplacedProblem >	getDisplacedProblem () const
virtual std::shared_ptr< DisplacedProblem >	getDisplacedProblem ()
virtual void	updateGeomSearch (GeometricSearchData::GeometricSearchType type=GeometricSearchData::ALL) override
virtual void	updateMortarMesh ()
void	createMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced, bool periodic, const bool debug, const bool correct_edge_dropping, const Real minimum_projection_angle)
const std::unordered_map< std::pair< BoundaryID, BoundaryID >, std::unique_ptr< AutomaticMortarGeneration > > &	getMortarInterfaces (bool on_displaced) const
virtual void	possiblyRebuildGeomSearchPatches ()
virtual GeometricSearchData &	geomSearchData () override
void	setRestartFile (const std::string &file_name)
	Communicate to the Resurector the name of the restart filer. More...
const MaterialPropertyRegistry &	getMaterialPropertyRegistry () const
const InitialConditionWarehouse &	getInitialConditionWarehouse () const
	Return InitialCondition storage. More...
const FVInitialConditionWarehouse &	getFVInitialConditionWarehouse () const
	Return FVInitialCondition storage. More...
SolverParams &	solverParams (unsigned int solver_sys_num=0)
	Get the solver parameters. More...
const SolverParams &	solverParams (unsigned int solver_sys_num=0) const
	const version More...
Adaptivity &	adaptivity ()
virtual void	initialAdaptMesh ()
virtual bool	adaptMesh ()
unsigned int	getNumCyclesCompleted ()
bool	hasInitialAdaptivity () const
	Return a Boolean indicating whether initial AMR is turned on. More...
bool	hasInitialAdaptivity () const
	Return a Boolean indicating whether initial AMR is turned on. More...
void	initXFEM (std::shared_ptr< XFEMInterface > xfem)
	Create XFEM controller object. More...
std::shared_ptr< XFEMInterface >	getXFEM ()
	Get a pointer to the XFEM controller object. More...
bool	haveXFEM ()
	Find out whether the current analysis is using XFEM. More...
virtual bool	updateMeshXFEM ()
	Update the mesh due to changing XFEM cuts. More...
virtual void	meshChanged (bool intermediate_change, bool contract_mesh, bool clean_refinement_flags)
	Update data after a mesh change. More...
void	notifyWhenMeshChanges (MeshChangedInterface *mci)
	Register an object that derives from MeshChangedInterface to be notified when the mesh changes. More...
void	notifyWhenMeshDisplaces (MeshDisplacedInterface *mdi)
	Register an object that derives from MeshDisplacedInterface to be notified when the displaced mesh gets updated. More...
void	initElementStatefulProps (const libMesh::ConstElemRange &elem_range, const bool threaded)
	Initialize stateful properties for elements in a specific elem_range This is needed when elements/boundary nodes are added to a specific subdomain at an intermediate step. More...
void	initKokkosStatefulProps ()
virtual void	checkProblemIntegrity ()
	Method called to perform a series of sanity checks before a simulation is run. More...
void	registerRandomInterface (RandomInterface &random_interface, const std::string &name)
void	setConstJacobian (bool state)
	Set flag that Jacobian is constant (for optimization purposes) More...
void	setKernelCoverageCheck (CoverageCheckMode mode)
	Set flag to indicate whether kernel coverage checks should be performed. More...
void	setKernelCoverageCheck (bool flag)
	Set flag to indicate whether kernel coverage checks should be performed. More...
void	setMaterialCoverageCheck (CoverageCheckMode mode)
	Set flag to indicate whether material coverage checks should be performed. More...
void	setMaterialCoverageCheck (bool flag)
	Set flag to indicate whether material coverage checks should be performed. More...
void	setParallelBarrierMessaging (bool flag)
	Toggle parallel barrier messaging (defaults to on). More...
void	setVerboseProblem (bool verbose)
	Make the problem be verbose. More...
bool	verboseMultiApps () const
	Whether or not to use verbose printing for MultiApps. More...
void	parentOutputPositionChanged ()
	Calls parentOutputPositionChanged() on all sub apps. More...
unsigned int	subspaceDim (const std::string &prefix) const
	Dimension of the subspace spanned by vectors with a given prefix. More...
const MaterialWarehouse &	getMaterialWarehouse () const
const MaterialWarehouse &	getRegularMaterialsWarehouse () const
const MaterialWarehouse &	getDiscreteMaterialWarehouse () const
const MaterialWarehouse &	getInterfaceMaterialsWarehouse () const
const MaterialWarehouse &	getKokkosMaterialsWarehouse () const
std::shared_ptr< MaterialBase >	getMaterial (std::string name, Moose::MaterialDataType type, const THREAD_ID tid=0, bool no_warn=false)
	Return a pointer to a MaterialBase object. More...
MaterialData &	getMaterialData (Moose::MaterialDataType type, const THREAD_ID tid=0, const MooseObject *object=nullptr) const
MaterialData &	getKokkosMaterialData (Moose::MaterialDataType type, const MooseObject *object=nullptr) const
const std::set< const MooseObject * > &	getMaterialPropertyStorageConsumers (Moose::MaterialDataType type) const
const std::set< const MooseObject * > &	getKokkosMaterialPropertyStorageConsumers (Moose::MaterialDataType type) const
bool	restoreOriginalNonzeroPattern () const
bool	errorOnJacobianNonzeroReallocation () const
	Will return True if the user wants to get an error when a nonzero is reallocated in the Jacobian by PETSc. More...
void	setErrorOnJacobianNonzeroReallocation (bool state)
bool	preserveMatrixSparsityPattern () const
	Will return True if the executioner in use requires preserving the sparsity pattern of the matrices being formed during the solve. More...
void	setPreserveMatrixSparsityPattern (bool preserve)
	Set whether the sparsity pattern of the matrices being formed during the solve (usually the Jacobian) should be preserved. More...
bool	ignoreZerosInJacobian () const
	Will return true if zeros in the Jacobian are to be dropped from the sparsity pattern. More...
void	setIgnoreZerosInJacobian (bool state)
	Set whether the zeros in the Jacobian should be dropped from the sparsity pattern. More...
bool	acceptInvalidSolution () const
	Whether or not to accept the solution based on its invalidity. More...
bool	allowInvalidSolution () const
	Whether to accept / allow an invalid solution. More...
bool	showInvalidSolutionConsole () const
	Whether or not to print out the invalid solutions summary table in console. More...
bool	immediatelyPrintInvalidSolution () const
	Whether or not the solution invalid warnings are printed out immediately. More...
bool	hasTimeIntegrator () const
	Returns whether or not this Problem has a TimeIntegrator. More...
virtual void	execute (const ExecFlagType &exec_type)
	Convenience function for performing execution of MOOSE systems. More...
virtual void	executeAllObjects (const ExecFlagType &exec_type)
virtual Executor &	getExecutor (const std::string &name)
virtual void	computeUserObjects (const ExecFlagType &type, const Moose::AuxGroup &group)
	Call compute methods on UserObjects. More...
virtual void	computeUserObjectByName (const ExecFlagType &type, const Moose::AuxGroup &group, const std::string &name)
	Compute an user object with the given name. More...
void	needsPreviousNewtonIteration (bool state)
	Set a flag that indicated that user required values for the previous Newton iterate. More...
bool	needsPreviousNewtonIteration () const
	Check to see whether we need to compute the variable values of the previous Newton iterate. More...
ExecuteMooseObjectWarehouse< Control > &	getControlWarehouse ()
	Reference to the control logic warehouse. More...
void	executeControls (const ExecFlagType &exec_type)
	Performs setup and execute calls for Control objects. More...
void	executeSamplers (const ExecFlagType &exec_type)
	Performs setup and execute calls for Sampler objects. More...
virtual void	updateActiveObjects ()
	Update the active objects in the warehouses. More...
void	reportMooseObjectDependency (MooseObject *a, MooseObject *b)
	Register a MOOSE object dependency so we can either order operations properly or report when we cannot. More...
ExecuteMooseObjectWarehouse< MultiApp > &	getMultiAppWarehouse ()
bool	hasJacobian () const
	Returns _has_jacobian. More...
bool	constJacobian () const
	Returns _const_jacobian (whether a MOOSE object has specified that the Jacobian is the same as the previous time it was computed) More...
void	addOutput (const std::string &, const std::string &, InputParameters &)
	Adds an Output object. More...
TheWarehouse &	theWarehouse () const
void	setSNESMFReuseBase (bool reuse, bool set_by_user)
	If or not to reuse the base vector for matrix-free calculation. More...
bool	useSNESMFReuseBase ()
	Return a flag that indicates if we are reusing the vector base. More...
void	skipExceptionCheck (bool skip_exception_check)
	Set a flag that indicates if we want to skip exception and stop solve. More...
bool	isSNESMFReuseBaseSetbyUser ()
	Return a flag to indicate if _snesmf_reuse_base is set by users. More...
bool &	petscOptionsInserted ()
	If PETSc options are already inserted. More...
PetscOptions &	petscOptionsDatabase ()
virtual void	setUDotRequested (const bool u_dot_requested)
	Set boolean flag to true to store solution time derivative. More...
virtual void	setUDotDotRequested (const bool u_dotdot_requested)
	Set boolean flag to true to store solution second time derivative. More...
virtual void	setUDotOldRequested (const bool u_dot_old_requested)
	Set boolean flag to true to store old solution time derivative. More...
virtual void	setUDotDotOldRequested (const bool u_dotdot_old_requested)
	Set boolean flag to true to store old solution second time derivative. More...
virtual bool	uDotRequested ()
	Get boolean flag to check whether solution time derivative needs to be stored. More...
virtual bool	uDotDotRequested ()
	Get boolean flag to check whether solution second time derivative needs to be stored. More...
virtual bool	uDotOldRequested ()
	Get boolean flag to check whether old solution time derivative needs to be stored. More...
virtual bool	uDotDotOldRequested ()
	Get boolean flag to check whether old solution second time derivative needs to be stored. More...
void	haveADObjects (bool have_ad_objects) override
	Method for setting whether we have any ad objects. More...
virtual void	haveADObjects (bool have_ad_objects)
	Method for setting whether we have any ad objects. More...
bool	haveADObjects () const
	Method for reading wehther we have any ad objects. More...
bool	haveADObjects () const
	Method for reading wehther we have any ad objects. More...
bool	shouldSolve () const
const MortarInterfaceWarehouse &	mortarData () const
	Returns the mortar data object. More...
MortarInterfaceWarehouse &	mortarData ()
virtual bool	hasNeighborCoupling () const
	Whether the simulation has neighbor coupling. More...
virtual bool	hasMortarCoupling () const
	Whether the simulation has mortar coupling. More...
void	computingNonlinearResid (bool computing_nonlinear_residual) final
	Set whether or not the problem is in the process of computing the nonlinear residual. More...
bool	computingNonlinearResid () const
	Returns true if the problem is in the process of computing the nonlinear residual. More...
virtual void	computingNonlinearResid (const bool computing_nonlinear_residual)
	Set whether or not the problem is in the process of computing the nonlinear residual. More...
bool	computingNonlinearResid () const
	Returns true if the problem is in the process of computing the nonlinear residual. More...
void	setCurrentlyComputingResidual (bool currently_computing_residual) final
	Set whether or not the problem is in the process of computing the residual. More...
void	numGridSteps (unsigned int num_grid_steps)
	Set the number of steps in a grid sequences. More...
void	uniformRefine ()
	uniformly refine the problem mesh(es). More...
void	automaticScaling (bool automatic_scaling) override
	Automatic scaling setter. More...
virtual void	automaticScaling (bool automatic_scaling)
	Automatic scaling setter. More...
bool	automaticScaling () const
	Automatic scaling getter. More...
bool	automaticScaling () const
	Automatic scaling getter. More...
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) override
	reinitialize FE objects on a given element on a given side at a given set of reference points and then compute variable data. More...
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) override
	reinitialize FE objects on a given neighbor element on a given side at a given set of reference points and then compute variable data. More...
bool	fvBCsIntegrityCheck () const
void	fvBCsIntegrityCheck (bool fv_bcs_integrity_check)
void	getFVMatsAndDependencies (SubdomainID block_id, std::vector< std::shared_ptr< MaterialBase >> &face_materials, std::vector< std::shared_ptr< MaterialBase >> &neighbor_materials, std::set< MooseVariableFieldBase *> &variables, const THREAD_ID tid)
	Get the materials and variables potentially needed for FV. More...
void	resizeMaterialData (Moose::MaterialDataType data_type, unsigned int nqp, const THREAD_ID tid)
	Resize material data. More...
bool	haveDisplaced () const override final
	Whether we have a displaced problem in our simulation. More...
bool	hasLinearConvergenceObjects () const
	Whether we have linear convergence objects. More...
void	setNonlinearConvergenceNames (const std::vector< ConvergenceName > &convergence_names)
	Sets the nonlinear convergence object name(s) if there is one. More...
void	setLinearConvergenceNames (const std::vector< ConvergenceName > &convergence_names)
	Sets the linear convergence object name(s) if there is one. More...
void	setMultiAppFixedPointConvergenceName (const ConvergenceName &convergence_name)
	Sets the MultiApp fixed point convergence object name if there is one. More...
void	setSteadyStateConvergenceName (const ConvergenceName &convergence_name)
	Sets the steady-state detection convergence object name if there is one. More...
const std::vector< ConvergenceName > &	getNonlinearConvergenceNames () const
	Gets the nonlinear system convergence object name(s). More...
const std::vector< ConvergenceName > &	getLinearConvergenceNames () const
	Gets the linear convergence object name(s). More...
const ConvergenceName &	getMultiAppFixedPointConvergenceName () const
	Gets the MultiApp fixed point convergence object name. More...
const ConvergenceName &	getSteadyStateConvergenceName () const
	Gets the steady-state detection convergence object name. More...
void	computingScalingJacobian (bool computing_scaling_jacobian)
	Setter for whether we're computing the scaling jacobian. More...
bool	computingScalingJacobian () const override final
	Getter for whether we're computing the scaling jacobian. More...
void	computingScalingResidual (bool computing_scaling_residual)
	Setter for whether we're computing the scaling residual. More...
bool	computingScalingResidual () const override final
MooseAppCoordTransform &	coordTransform ()
virtual std::size_t	numNonlinearSystems () const override
virtual std::size_t	numLinearSystems () const override
virtual std::size_t	numSolverSystems () const override
bool	isSolverSystemNonlinear (const unsigned int sys_num)
	Check if the solver system is nonlinear. More...
virtual unsigned int	currentNlSysNum () const override
virtual unsigned int	currentLinearSysNum () const override
virtual unsigned int	nlSysNum (const NonlinearSystemName &nl_sys_name) const override
unsigned int	linearSysNum (const LinearSystemName &linear_sys_name) const override
unsigned int	solverSysNum (const SolverSystemName &solver_sys_name) const override
unsigned int	systemNumForVariable (const VariableName &variable_name) const
bool	getFailNextNonlinearConvergenceCheck () const
	Whether it will skip further residual evaluations and fail the next nonlinear convergence check(s) More...
bool	getFailNextSystemConvergenceCheck () const
	Whether it will fail the next system convergence check(s), triggering failed step behavior. More...
void	setFailNextNonlinearConvergenceCheck ()
	Skip further residual evaluations and fail the next nonlinear convergence check(s) More...
void	setFailNextSystemConvergenceCheck ()
	Tell the problem that the system(s) cannot be considered converged next time convergence is checked. More...
void	resetFailNextNonlinearConvergenceCheck ()
	Tell the problem that the nonlinear convergence check(s) may proceed as normal. More...
void	resetFailNextSystemConvergenceCheck ()
	Tell the problem that the system convergence check(s) may proceed as normal. More...
void	setExecutionPrinting (const ExecFlagEnum &print_exec)
bool	shouldPrintExecution (const THREAD_ID tid) const
	Check whether the problem should output execution orders at this time. More...
void	reinitMortarUserObjects (BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced)
	Call reinit on mortar user objects with matching primary boundary ID, secondary boundary ID, and displacement characteristics. More...
virtual const std::vector< VectorTag > &	currentResidualVectorTags () const override
	Return the residual vector tags we are currently computing. More...
void	setCurrentResidualVectorTags (const std::set< TagID > &vector_tags)
	Set the current residual vector tag data structure based on the passed in tag IDs. More...
void	clearCurrentResidualVectorTags ()
	Clear the current residual vector tag data structure. More...
void	clearCurrentJacobianMatrixTags ()
	Clear the current Jacobian matrix tag data structure ... More...
virtual void	needFV () override
	marks this problem as including/needing finite volume functionality. More...
virtual bool	haveFV () const override
	returns true if this problem includes/needs finite volume functionality. More...
virtual bool	hasNonlocalCoupling () const override
	Whether the simulation has active nonlocal coupling which should be accounted for in the Jacobian. More...
bool	identifyVariableGroupsInNL () const
	Whether to identify variable groups in nonlinear systems. More...
virtual void	setCurrentLowerDElem (const Elem *const lower_d_elem, const THREAD_ID tid) override
	Set the current lower dimensional element. More...
virtual void	setCurrentBoundaryID (BoundaryID bid, const THREAD_ID tid) override
	sets the current boundary ID in assembly More...
const std::vector< NonlinearSystemName > &	getNonlinearSystemNames () const
const std::vector< LinearSystemName > &	getLinearSystemNames () const
const std::vector< SolverSystemName > &	getSolverSystemNames () const
virtual const libMesh::CouplingMatrix &	nonlocalCouplingMatrix (const unsigned i) const override
virtual bool	checkNonlocalCouplingRequirement () const override
void	createTagMatrices (CreateTaggedMatrixKey)
bool	hasKokkosObjects () const
bool	hasKokkosResidualObjects () const
const bool &	currentlyComputingResidual () const
	Returns true if the problem is in the process of computing the residual. More...
const bool &	currentlyComputingResidual () const
	Returns true if the problem is in the process of computing the residual. More...
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. More...
bool	defaultGhosting ()
	Whether or not the user has requested default ghosting ot be on. More...
virtual TagID	addVectorTag (const TagName &tag_name, const Moose::VectorTagType type=Moose::VECTOR_TAG_RESIDUAL)
	Create a Tag. More...
void	addNotZeroedVectorTag (const TagID tag)
	Adds a vector tag to the list of vectors that will not be zeroed when other tagged vectors are. More...
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. More...
virtual const VectorTag &	getVectorTag (const TagID tag_id) const
	Get a VectorTag from a TagID. More...
std::vector< VectorTag >	getVectorTags (const std::set< TagID > &tag_ids) const
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. More...
virtual TagID	getVectorTagID (const TagName &tag_name) const
	Get a TagID from a TagName. More...
virtual TagName	vectorTagName (const TagID tag) const
	Retrieve the name associated with a TagID. More...
virtual bool	vectorTagExists (const TagID tag_id) const
	Check to see if a particular Tag exists. More...
virtual bool	vectorTagExists (const TagName &tag_name) const
	Check to see if a particular Tag exists by using Tag name. More...
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. More...
virtual Moose::VectorTagType	vectorTagType (const TagID tag_id) const
virtual TagID	addMatrixTag (TagName tag_name)
	Create a Tag. More...
virtual TagID	getMatrixTagID (const TagName &tag_name) const
	Get a TagID from a TagName. More...
virtual TagName	matrixTagName (TagID tag)
	Retrieve the name associated with a TagID. More...
virtual bool	matrixTagExists (const TagName &tag_name) const
	Check to see if a particular Tag exists. More...
virtual bool	matrixTagExists (TagID tag_id) const
	Check to see if a particular Tag exists. More...
virtual unsigned int	numMatrixTags () const
	The total number of tags. More...
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. More...
virtual bool	hasLinearVariable (const std::string &var_name) const
	Whether or not this problem has this linear variable. More...
virtual bool	hasAuxiliaryVariable (const std::string &var_name) const
	Whether or not this problem has this auxiliary variable. More...
virtual const std::set< MooseVariableFieldBase * > &	getActiveElementalMooseVariables (const THREAD_ID tid) const
	Get the MOOSE variables to be reinited on each element. More...
virtual bool	hasActiveElementalMooseVariables (const THREAD_ID tid) const
	Whether or not a list of active elemental moose variables has been set. More...
Moose::CoordinateSystemType	getCoordSystem (SubdomainID sid) const
unsigned int	getAxisymmetricRadialCoord () const
	Returns the desired radial direction for RZ coordinate transformation. More...
virtual DiracKernelInfo &	diracKernelInfo ()
void	reinitNeighborLowerDElem (const Elem *elem, const THREAD_ID tid=0)
	reinitialize a neighboring lower dimensional element More...
void	reinitMortarElem (const Elem *elem, const THREAD_ID tid=0)
	Reinit a mortar element to obtain a valid JxW. More...
virtual void	storeSubdomainMatPropName (SubdomainID block_id, const std::string &name)
	Adds the given material property to a storage map based on block ids. More...
virtual void	storeBoundaryMatPropName (BoundaryID boundary_id, const std::string &name)
	Adds the given material property to a storage map based on boundary ids. More...
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. More...
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. More...
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. More...
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. More...
virtual void	checkBlockMatProps ()
	Checks block material properties integrity. More...
virtual void	checkBoundaryMatProps ()
	Checks boundary material properties integrity. More...
virtual void	markMatPropRequested (const std::string &)
	Helper method for adding a material property name to the _material_property_requested set. More...
virtual bool	isMatPropRequested (const std::string &prop_name) const
	Find out if a material property has been requested by any object. More...
void	addConsumedPropertyName (const MooseObjectName &obj_name, const std::string &prop_name)
	Helper for tracking the object that is consuming a property for MaterialPropertyDebugOutput. More...
const std::map< MooseObjectName, std::set< std::string > > &	getConsumedPropertyMap () const
	Return the map that tracks the object with consumed material properties. More...
virtual std::set< SubdomainID >	getMaterialPropertyBlocks (const std::string &prop_name)
	Get a vector containing the block ids the material property is defined on. More...
virtual std::vector< SubdomainName >	getMaterialPropertyBlockNames (const std::string &prop_name)
	Get a vector of block id equivalences that the material property is defined on. More...
virtual bool	hasBlockMaterialProperty (SubdomainID block_id, const std::string &prop_name)
	Check if a material property is defined on a block. More...
virtual std::set< BoundaryID >	getMaterialPropertyBoundaryIDs (const std::string &prop_name)
	Get a vector containing the block ids the material property is defined on. More...
virtual std::vector< BoundaryName >	getMaterialPropertyBoundaryNames (const std::string &prop_name)
	Get a vector of block id equivalences that the material property is defined on. More...
virtual bool	hasBoundaryMaterialProperty (BoundaryID boundary_id, const std::string &prop_name)
	Check if a material property is defined on a block. More...
virtual std::set< dof_id_type > &	ghostedElems ()
	Return the list of elements that should have their DoFs ghosted to this processor. More...
const bool &	currentlyComputingJacobian () const
	Returns true if the problem is in the process of computing the Jacobian. More...
void	setCurrentlyComputingJacobian (const bool currently_computing_jacobian)
	Set whether or not the problem is in the process of computing the Jacobian. More...
const bool &	currentlyComputingResidualAndJacobian () const
	Returns true if the problem is in the process of computing the residual and the Jacobian. More...
void	setCurrentlyComputingResidualAndJacobian (bool currently_computing_residual_and_jacobian)
	Set whether or not the problem is in the process of computing the Jacobian. More...
virtual bool	safeAccessTaggedMatrices () const
	Is it safe to access the tagged matrices. More...
virtual bool	safeAccessTaggedVectors () const
	Is it safe to access the tagged vectors. More...
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
void	addAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf, bool to_mesh=true)
	Add an algebraic ghosting functor to this problem's DofMaps. More...
void	addCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf, bool to_mesh=true)
	Add a coupling functor to this problem's DofMaps. More...
void	removeAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf)
	Remove an algebraic ghosting functor from this problem's DofMaps. More...
void	removeCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf)
	Remove a coupling ghosting functor from this problem's DofMaps. More...
void	hasScalingVector (const unsigned int nl_sys_num)
	Tells this problem that the assembly associated with the given nonlinear system number involves a scaling vector. More...
void	clearAllDofIndices ()
	Clear dof indices from variables in nl and aux systems. More...
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 More...
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 More...
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 More...
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. More...
void	setFunctorOutput (bool set_output)
	Setter for debug functor output. More...
void	setChainControlDataOutput (bool set_output)
	Setter for debug chain control data output. More...
template<typename T >
void	registerUnfilledFunctorRequest (T *functor_interface, const std::string &functor_name, const THREAD_ID tid)
	Register an unfulfilled functor request. More...
void	reinitFVFace (const THREAD_ID tid, const FaceInfo &fi)
	reinitialize the finite volume assembly data for the provided face and thread More...
void	preparePRefinement ()
	Prepare DofMap and Assembly classes with our p-refinement information. More...
bool	doingPRefinement () const
bool	havePRefinement () const
	Query whether p-refinement has been requested at any point during the simulation. More...
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
void	_setCLIOption ()
	For Internal Use. More...
virtual void	terminateSolve ()
	Allow objects to request clean termination of the solve. More...
virtual bool	isSolveTerminationRequested () const
	Check of termination has been requested. More...
const ConsoleStream &	console () const
	Return console handle. More...
virtual bool	enabled () const
	Return the enabled status of the object. More...
std::shared_ptr< MooseObject >	getSharedPtr ()
	Get another shared pointer to this object that has the same ownership group. More...
std::shared_ptr< const MooseObject >	getSharedPtr () const
bool	isKokkosObject (IsKokkosObjectKey &&) const
	Get whether this object is a Kokkos functor The parameter is set by the Kokkos base classes: More...
MooseApp &	getMooseApp () const
	Get the MooseApp this class is associated with. More...
const std::string &	type () const
	Get the type of this class. More...
const std::string &	name () const
	Get the name of the class. More...
std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling. More...
MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const
MooseObjectName	uniqueName () const
const InputParameters &	parameters () const
	Get the parameters of the object. More...
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. More...
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. More...
template<typename T >
const T *	queryParam (const std::string &name) const
	Query a parameter for the object. More...
template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object. More...
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. More...
bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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. More...
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(). More...
template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type. More...
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(). More...
template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
template<typename... Args>
void	mooseDeprecated (Args &&... args) const
template<typename... Args>
void	mooseInfo (Args &&... args) const
void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr) const
	External method for calling moose error with added object context. More...
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. More...
std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method. More...
std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path. More...
PerfGraph &	perfGraph ()
	Get the PerfGraph. More...
const libMesh::ConstElemRange &	getEvaluableElementRange ()
	In general, {evaluable elements} >= {local elements} U {algebraic ghosting elements}. More...
const libMesh::ConstElemRange &	getNonlinearEvaluableElementRange ()
const libMesh::ConstElemRange &	getCurrentAlgebraicElementRange ()
	These are the element and nodes that contribute to the jacobian and residual for this local processor. More...
const libMesh::ConstNodeRange &	getCurrentAlgebraicNodeRange ()
const ConstBndNodeRange &	getCurrentAlgebraicBndNodeRange ()
void	setCurrentAlgebraicElementRange (libMesh::ConstElemRange *range)
	These functions allow setting custom ranges for the algebraic elements, nodes, and boundary nodes that contribute to the jacobian and residual for this local processor. More...
void	setCurrentAlgebraicNodeRange (libMesh::ConstNodeRange *range)
void	setCurrentAlgebraicBndNodeRange (ConstBndNodeRange *range)
void	allowOutput (bool state)
	Ability to enable/disable all output calls. More...
template<typename T >
void	allowOutput (bool state)
bool	hasMultiApps () const
	Returns whether or not the current simulation has any multiapps. More...
bool	hasMultiApps (ExecFlagType type) const
bool	hasMultiApp (const std::string &name) const
const AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced) const
	Return the undisplaced or displaced mortar generation object associated with the provided boundaries and subdomains. More...
AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced)
const MaterialPropertyStorage &	getMaterialPropertyStorage ()
	Return a reference to the material property storage. More...
const MaterialPropertyStorage &	getBndMaterialPropertyStorage ()
const MaterialPropertyStorage &	getNeighborMaterialPropertyStorage ()
Moose::Kokkos::MaterialPropertyStorage &	getKokkosMaterialPropertyStorage ()
Moose::Kokkos::MaterialPropertyStorage &	getKokkosBndMaterialPropertyStorage ()
Moose::Kokkos::MaterialPropertyStorage &	getKokkosNeighborMaterialPropertyStorage ()
const MooseObjectWarehouse< Indicator > &	getIndicatorWarehouse ()
	Return indicator/marker storage. More...
const MooseObjectWarehouse< InternalSideIndicatorBase > &	getInternalSideIndicatorWarehouse ()
const MooseObjectWarehouse< Marker > &	getMarkerWarehouse ()
bool	needBoundaryMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)
	These methods are used to determine whether stateful material properties need to be stored on internal sides. More...
bool	needInterfaceMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)
bool	needInternalNeighborSideMaterial (SubdomainID subdomain_id, const THREAD_ID tid)
const ExecFlagType &	getCurrentExecuteOnFlag () const
	Return/set the current execution flag. More...
void	setCurrentExecuteOnFlag (const ExecFlagType &)

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. More...
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. More...
static void	callMooseError (MooseApp *const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node *node)
	External method for calling moose error with added object context. More...
template<typename T >
static void	objectSetupHelper (const std::vector< T *> &objects, const ExecFlagType &exec_flag)
	Helpers for calling the necessary setup/execute functions for the supplied objects. More...
template<typename T >
static void	objectExecuteHelper (const std::vector< T *> &objects)

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. More...
std::vector< Real >	_real_zero
	Convenience zeros. More...
std::vector< VariableValue >	_scalar_zero
std::vector< VariableValue >	_zero
std::vector< VariablePhiValue >	_phi_zero
std::vector< MooseArray< ADReal > >	_ad_zero
std::vector< VariableGradient >	_grad_zero
std::vector< MooseArray< ADRealVectorValue > >	_ad_grad_zero
std::vector< VariablePhiGradient >	_grad_phi_zero
std::vector< VariableSecond >	_second_zero
std::vector< MooseArray< ADRealTensorValue > >	_ad_second_zero
std::vector< VariablePhiSecond >	_second_phi_zero
std::vector< Point >	_point_zero
std::vector< VectorVariableValue >	_vector_zero
std::vector< VectorVariableCurl >	_vector_curl_zero

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

Protected Member Functions
virtual void	meshChanged ()
	Deprecated. More...
void	createTagVectors ()
	Create extra tagged vectors and matrices. More...
void	createTagSolutions ()
	Create extra tagged solution vectors. More...
virtual void	meshDisplaced ()
	Update data after a mesh displaced. More...
void	computeSystems (const ExecFlagType &type)
	Do generic system computations. More...
bool	duplicateVariableCheck (const std::string &var_name, const libMesh::FEType &type, bool is_aux, const std::set< SubdomainID > *const active_subdomains)
	Helper to check for duplicate variable names across systems or within a single system. More...
void	computeUserObjectsInternal (const ExecFlagType &type, const Moose::AuxGroup &group, TheWarehouse::Query &query)
void	checkDisplacementOrders ()
	Verify that SECOND order mesh uses SECOND order displacements. More...
void	checkUserObjects ()
void	checkDependMaterialsHelper (const std::map< SubdomainID, std::vector< std::shared_ptr< MaterialBase >>> &materials_map)
	Helper method for checking Material object dependency. More...
void	checkCoordinateSystems ()
	Verify that there are no element type/coordinate type conflicts. More...
void	reinitBecauseOfGhostingOrNewGeomObjects (bool mortar_changed=false)
	Call when it is possible that the needs for ghosted elements has changed. More...
void	addObjectParamsHelper (InputParameters &params, const std::string &object_name, const std::string &var_param_name="variable")
	Helper for setting the "_subproblem" and "_sys" parameters in addObject() and in addUserObject(). More...
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. More...
bool	verifyVectorTags () const
	Verify the integrity of _vector_tags and _typed_vector_tags. More...
void	markFamilyPRefinement (const InputParameters &params)
	Mark a variable family for either disabling or enabling p-refinement with valid parameters of a variable. More...
template<bool warning>
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
	Set solution invalid mark for the given solution ID. More...
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. More...
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. More...
std::string	timedSectionName (const std::string &section_name) const
template<typename T , typename... Args>
T &	declareRestartableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T , typename... Args>
ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declares a piece of "managed" restartable data and initialize it. More...
template<typename T , typename... Args>
const T &	getRestartableData (const std::string &data_name) const
	Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object. More...
template<typename T , typename... Args>
T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declare a piece of data as "restartable" and initialize it. More...
template<typename T , typename... Args>
T &	declareRecoverableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "recoverable" and initialize it. More...
template<typename T , typename... Args>
T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)
	Declare a piece of data as "restartable". More...
template<typename T , typename... Args>
T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)
	Declare a piece of data as "restartable". More...
std::string	restartableName (const std::string &data_name) const
	Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix. More...

Protected Attributes
MFEMProblemData	_problem_data
MooseMesh &	_mesh
bool	_initialized
std::optional< std::vector< ConvergenceName > >	_nonlinear_convergence_names
	Nonlinear system(s) convergence name(s) More...
std::optional< std::vector< ConvergenceName > >	_linear_convergence_names
	Linear system(s) convergence name(s) (if any) More...
std::optional< ConvergenceName >	_multiapp_fixed_point_convergence_name
	MultiApp fixed point convergence name. More...
std::optional< ConvergenceName >	_steady_state_convergence_name
	Steady-state detection convergence name. More...
std::set< TagID >	_fe_vector_tags
std::set< TagID >	_fe_matrix_tags
std::set< TagID >	_linear_vector_tags
	Temporary storage for filtered vector tags for linear systems. More...
std::set< TagID >	_linear_matrix_tags
	Temporary storage for filtered matrix tags for linear systems. More...
const bool &	_solve
	Whether or not to actually solve the nonlinear system. More...
bool	_transient
Real &	_time
Real &	_time_old
int &	_t_step
Real &	_dt
Real &	_dt_old
bool	_need_to_add_default_nonlinear_convergence
	Flag that the problem needs to add the default nonlinear convergence. More...
bool	_need_to_add_default_multiapp_fixed_point_convergence
	Flag that the problem needs to add the default fixed point convergence. More...
bool	_need_to_add_default_steady_state_convergence
	Flag that the problem needs to add the default steady convergence. More...
const std::vector< LinearSystemName >	_linear_sys_names
	The linear system names. More...
const std::size_t	_num_linear_sys
	The number of linear systems. More...
std::vector< std::shared_ptr< LinearSystem > >	_linear_systems
	The vector of linear systems. More...
std::map< LinearSystemName, unsigned int >	_linear_sys_name_to_num
	Map from linear system name to number. More...
LinearSystem *	_current_linear_sys
	The current linear system that we are solving. More...
const bool	_using_default_nl
	Boolean to check if we have the default nonlinear system. More...
const std::vector< NonlinearSystemName >	_nl_sys_names
	The nonlinear system names. More...
const std::size_t	_num_nl_sys
	The number of nonlinear systems. More...
std::vector< std::shared_ptr< NonlinearSystemBase > >	_nl
	The nonlinear systems. More...
std::map< NonlinearSystemName, unsigned int >	_nl_sys_name_to_num
	Map from nonlinear system name to number. More...
NonlinearSystemBase *	_current_nl_sys
	The current nonlinear system that we are solving. More...
SolverSystem *	_current_solver_sys
	The current solver system. More...
std::vector< std::shared_ptr< SolverSystem > >	_solver_systems
	Combined container to base pointer of every solver system. More...
std::map< SolverVariableName, unsigned int >	_solver_var_to_sys_num
	Map connecting variable names with their respective solver systems. More...
std::map< SolverSystemName, unsigned int >	_solver_sys_name_to_num
	Map connecting solver system names with their respective systems. More...
std::vector< SolverSystemName >	_solver_sys_names
	The union of nonlinear and linear system names. More...
std::shared_ptr< AuxiliarySystem >	_aux
	The auxiliary system. More...
Moose::CouplingType	_coupling
	Type of variable coupling. More...
std::vector< std::unique_ptr< libMesh::CouplingMatrix > >	_cm
	Coupling matrix for variables. More...
Moose::Kokkos::Array< Moose::Kokkos::System >	_kokkos_systems
std::map< std::string, unsigned int >	_subspace_dim
	Dimension of the subspace spanned by the vectors with a given prefix. More...
std::vector< std::vector< std::unique_ptr< Assembly > > >	_assembly
	The Assembly objects. More...
Moose::Kokkos::Assembly	_kokkos_assembly
MooseObjectWarehouse< MeshDivision >	_mesh_divisions
	Warehouse to store mesh divisions NOTE: this could probably be moved to the MooseMesh instead of the Problem Time (and people's uses) will tell where this fits best. More...
MooseObjectWarehouse< Function >	_functions
	functions More...
MooseObjectWarehouse< Convergence >	_convergences
	convergence warehouse More...
MooseObjectWarehouse< KernelBase >	_nonlocal_kernels
	nonlocal kernels More...
MooseObjectWarehouse< IntegratedBCBase >	_nonlocal_integrated_bcs
	nonlocal integrated_bcs More...
MaterialPropertyRegistry	_material_prop_registry
MaterialPropertyStorage &	_material_props
MaterialPropertyStorage &	_bnd_material_props
MaterialPropertyStorage &	_neighbor_material_props
Moose::Kokkos::MaterialPropertyStorage &	_kokkos_material_props
Moose::Kokkos::MaterialPropertyStorage &	_kokkos_bnd_material_props
Moose::Kokkos::MaterialPropertyStorage &	_kokkos_neighbor_material_props
MooseObjectWarehouse< Marker >	_markers
ReporterData	_reporter_data
ExecuteMooseObjectWarehouse< UserObject >	_all_user_objects
ExecuteMooseObjectWarehouse< MultiApp >	_multi_apps
	MultiApp Warehouse. More...
ExecuteMooseObjectWarehouse< TransientMultiApp >	_transient_multi_apps
	Storage for TransientMultiApps (only needed for calling 'computeDT') More...
ExecuteMooseObjectWarehouse< Transfer >	_transfers
	Normal Transfers. More...
ExecuteMooseObjectWarehouse< Transfer >	_to_multi_app_transfers
	Transfers executed just before MultiApps to transfer data to them. More...
ExecuteMooseObjectWarehouse< Transfer >	_from_multi_app_transfers
	Transfers executed just after MultiApps to transfer data from them. More...
ExecuteMooseObjectWarehouse< Transfer >	_between_multi_app_transfers
	Transfers executed just before MultiApps to transfer data between them. More...
std::map< std::string, std::unique_ptr< RandomData > >	_random_data_objects
	A map of objects that consume random numbers. More...
std::vector< std::unordered_map< SubdomainID, bool > >	_block_mat_side_cache
	Cache for calculating materials on side. More...
std::vector< std::unordered_map< BoundaryID, bool > >	_bnd_mat_side_cache
	Cache for calculating materials on side. More...
std::vector< std::unordered_map< BoundaryID, bool > >	_interface_mat_side_cache
	Cache for calculating materials on interface. More...
std::vector< MeshChangedInterface * >	_notify_when_mesh_changes
	Objects to be notified when the mesh changes. More...
std::vector< MeshDisplacedInterface * >	_notify_when_mesh_displaces
	Objects to be notified when the mesh displaces. More...
Adaptivity	_adaptivity
unsigned int	_cycles_completed
std::shared_ptr< XFEMInterface >	_xfem
	Pointer to XFEM controller. More...
MooseMesh *	_displaced_mesh
std::shared_ptr< DisplacedProblem >	_displaced_problem
GeometricSearchData	_geometric_search_data
std::unique_ptr< MortarInterfaceWarehouse >	_mortar_data
bool	_reinit_displaced_elem
	Whether to call DisplacedProblem::reinitElem when this->reinitElem is called. More...
bool	_reinit_displaced_face
	Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called. More...
bool	_reinit_displaced_neighbor
	Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called. More...
bool	_input_file_saved
	whether input file has been written More...
bool	_has_dampers
	Whether or not this system has any Dampers associated with it. More...
bool	_has_constraints
	Whether or not this system has any Constraints. More...
bool	_snesmf_reuse_base
	If or not to resuse the base vector for matrix-free calculation. More...
bool	_skip_exception_check
	If or not skip 'exception and stop solve'. More...
bool	_snesmf_reuse_base_set_by_user
	If or not _snesmf_reuse_base is set by user. More...
bool	_has_initialized_stateful
	Whether nor not stateful materials have been initialized. More...
bool	_const_jacobian
	true if the Jacobian is constant More...
bool	_has_jacobian
	Indicates if the Jacobian was computed. More...
bool	_needs_old_newton_iter
	Indicates that we need to compute variable values for previous Newton iteration. More...
bool	_previous_nl_solution_required
	Indicates we need to save the previous NL iteration variable values. More...
bool	_has_nonlocal_coupling
	Indicates if nonlocal coupling is required/exists. More...
bool	_calculate_jacobian_in_uo
std::vector< std::vector< const MooseVariableFEBase * > >	_uo_jacobian_moose_vars
std::vector< unsigned char >	_has_active_material_properties
	Whether there are active material properties on each thread. More...
std::vector< SolverParams >	_solver_params
CoverageCheckMode	_kernel_coverage_check
	Determines whether and which subdomains are to be checked to ensure that they have an active kernel. More...
std::vector< SubdomainName >	_kernel_coverage_blocks
const bool	_boundary_restricted_node_integrity_check
	whether to perform checking of boundary restricted nodal object variable dependencies, e.g. More...
const bool	_boundary_restricted_elem_integrity_check
	whether to perform checking of boundary restricted elemental object variable dependencies, e.g. More...
CoverageCheckMode	_material_coverage_check
	Determines whether and which subdomains are to be checked to ensure that they have an active material. More...
std::vector< SubdomainName >	_material_coverage_blocks
bool	_fv_bcs_integrity_check
	Whether to check overlapping Dirichlet and Flux BCs and/or multiple DirichletBCs per sideset. More...
const bool	_material_dependency_check
	Determines whether a check to verify material dependencies on every subdomain. More...
const bool	_uo_aux_state_check
	Whether or not checking the state of uo/aux evaluation. More...
unsigned int	_max_qps
	Maximum number of quadrature points used in the problem. More...
libMesh::Order	_max_scalar_order
	Maximum scalar variable order. More...
bool	_has_time_integrator
	Indicates whether or not this executioner has a time integrator (during setup) More...
bool	_has_exception
	Whether or not an exception has occurred. More...
bool	_parallel_barrier_messaging
	Whether or not information about how many transfers have completed is printed. More...
MooseEnum	_verbose_setup
	Whether or not to be verbose during setup. More...
bool	_verbose_multiapps
	Whether or not to be verbose with multiapps. More...
bool	_verbose_restore
	Whether or not to be verbose on solution restoration post a failed time step. More...
std::string	_exception_message
	The error message to go with an exception. More...
ExecFlagType	_current_execute_on_flag
	Current execute_on flag. More...
ExecuteMooseObjectWarehouse< Control >	_control_warehouse
	The control logic warehouse. More...
Moose::PetscSupport::PetscOptions	_petsc_options
	PETSc option storage. More...
PetscOptions	_petsc_option_data_base
bool	_is_petsc_options_inserted
	If or not PETSc options have been added to database. More...
std::shared_ptr< LineSearch >	_line_search
std::unique_ptr< libMesh::ConstElemRange >	_evaluable_local_elem_range
std::unique_ptr< libMesh::ConstElemRange >	_nl_evaluable_local_elem_range
std::unique_ptr< libMesh::ConstElemRange >	_aux_evaluable_local_elem_range
std::unique_ptr< libMesh::ConstElemRange >	_current_algebraic_elem_range
std::unique_ptr< libMesh::ConstNodeRange >	_current_algebraic_node_range
std::unique_ptr< ConstBndNodeRange >	_current_algebraic_bnd_node_range
bool	_using_ad_mat_props
	Automatic differentiaion (AD) flag which indicates whether any consumer has requested an AD material property or whether any suppier has declared an AD material property. More...
unsigned short	_current_ic_state
const bool	_use_hash_table_matrix_assembly
	Whether to assemble matrices using hash tables instead of preallocating matrix memory. More...
std::map< TagName, TagID >	_matrix_tag_name_to_tag_id
	The currently declared tags. More...
std::map< TagID, TagName >	_matrix_tag_id_to_tag_name
	Reverse map. More...
Factory &	_factory
	The Factory for building objects. More...
DiracKernelInfo	_dirac_kernel_info
std::map< SubdomainID, std::set< std::string > >	_map_block_material_props
	Map of material properties (block_id -> list of properties) More...
std::map< BoundaryID, std::set< std::string > >	_map_boundary_material_props
	Map for boundary material properties (boundary_id -> list of properties) More...
std::map< SubdomainID, std::set< MaterialPropertyName > >	_zero_block_material_props
	Set of properties returned as zero properties. More...
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* More...
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) More...
std::vector< unsigned int >	_has_active_elemental_moose_variables
	Whether or not there is currently a list of active elemental moose variables. More...
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. More...
std::set< dof_id_type >	_ghosted_elems
	Elements that should have Dofs ghosted to the local processor. More...
bool	_currently_computing_jacobian
	Flag to determine whether the problem is currently computing Jacobian. More...
bool	_currently_computing_residual_and_jacobian
	Flag to determine whether the problem is currently computing the residual and Jacobian. More...
bool	_computing_nonlinear_residual
	Whether the non-linear residual is being evaluated. More...
bool	_currently_computing_residual
	Whether the residual is being evaluated. More...
bool	_safe_access_tagged_matrices
	Is it safe to retrieve data from tagged matrices. More...
bool	_safe_access_tagged_vectors
	Is it safe to retrieve data from tagged vectors. More...
bool	_have_ad_objects
	AD flag indicating whether any AD objects have been added. More...
std::unordered_set< TagID >	_not_zeroed_tagged_vectors
	the list of vector tags that will not be zeroed when all other tags are More...
bool	_cli_option_found
	True if the CLI option is found. More...
bool	_color_output
	True if we're going to attempt to write color output. More...
bool	_termination_requested
	True if termination of the solve has been requested. More...
const bool &	_enabled
	Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects. More...
MooseApp &	_app
	The MOOSE application this is associated with. More...
ActionFactory &	_action_factory
	Builds Actions. More...
const std::string &	_type
	The type of this class. More...
const std::string &	_name
	The name of this class. More...
const InputParameters &	_pars
	The object's parameters. More...
const Parallel::Communicator &	_communicator
MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph. More...
const std::string	_prefix
	A prefix to use for all sections. More...
MooseApp &	_restartable_app
	Reference to the application. More...
const std::string	_restartable_system_name
	The system name this object is in. More...
const THREAD_ID	_restartable_tid
	The thread ID for this object. More...
const bool	_restartable_read_only
	Flag for toggling read only status (see ReporterData) More...
InitialConditionWarehouse	_ics
FVInitialConditionWarehouse	_fv_ics
ScalarInitialConditionWarehouse	_scalar_ics
MaterialWarehouse	_materials
MaterialWarehouse	_interface_materials
MaterialWarehouse	_discrete_materials
MaterialWarehouse	_all_materials
MaterialWarehouse	_kokkos_materials
MooseObjectWarehouse< Indicator >	_indicators
MooseObjectWarehouse< InternalSideIndicatorBase >	_internal_side_indicators
std::map< SubdomainID, std::multimap< std::string, std::string > >	_map_block_material_props_check
	Data structures of the requested material properties. More...
std::map< BoundaryID, std::multimap< std::string, std::string > >	_map_boundary_material_props_check

Detailed Description

Definition at line 17 of file MFEMProblem.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

CoverageCheckMode

enum FEProblemBase::CoverageCheckMode

stronginherited

Enumerator
FALSE
TRUE
OFF
ON
SKIP_LIST
ONLY_LIST

Definition at line 152 of file FEProblemBase.h.

  {
    FALSE,
    TRUE,
    OFF,
    ON,
    SKIP_LIST,
    ONLY_LIST,
  };

Direction

enum ExternalProblem::Direction : unsigned char

stronginherited

Enumerator
TO_EXTERNAL_APP
FROM_EXTERNAL_APP

Definition at line 21 of file ExternalProblem.h.

                       : unsigned char
  {
    TO_EXTERNAL_APP,
    FROM_EXTERNAL_APP
  };

Constructor & Destructor Documentation

MFEMProblem()

MFEMProblem::MFEMProblem

(

const InputParameters &

params

)

Definition at line 33 of file MFEMProblem.C.

                                                       : ExternalProblem(params)
{
  // Initialise Hypre for all MFEM problems.
  mfem::Hypre::Init();
  // Disable multithreading for all MFEM problems (including any libMesh or MFEM subapps).
  libMesh::libMeshPrivateData::_n_threads = 1;
  setMesh();
}

~MFEMProblem()

virtual MFEMProblem::~MFEMProblem ( )

inlinevirtual

Definition at line 23 of file MFEMProblem.h.

{}

Member Function Documentation

_setCLIOption()

void Problem::_setCLIOption ( )

inlineinherited

For Internal Use.

Definition at line 32 of file Problem.h.

{ _cli_option_found = true; }

acceptInvalidSolution()

bool FEProblemBase::acceptInvalidSolution ( ) const

inherited

Whether or not to accept the solution based on its invalidity.

If this returns false, it means that an invalid solution was encountered (an error) that was not allowed.

Definition at line 3963 of file FEProblemBase.C.

Referenced by SolverSystem::checkInvalidSolution(), and NonlinearSystem::converged().

{
  return allowInvalidSolution() || // invalid solutions are always allowed
         !_app.solutionInvalidity().hasInvalidSolutionError(); // if not allowed, check for errors
}

adaptivity()

Adaptivity& FEProblemBase::adaptivity ( )

inlineinherited

Definition at line 1905 of file FEProblemBase.h.

Referenced by SteadyBase::execute(), Eigenvalue::execute(), FEProblemBase::initialAdaptMesh(), and FEProblemBase::initialSetup().

{ return _adaptivity; }

adaptMesh()

bool FEProblemBase::adaptMesh ( )

virtualinherited

Returns

Whether or not the mesh was changed

Reimplemented in DumpObjectsProblem.

Definition at line 8191 of file FEProblemBase.C.

Referenced by SteadyBase::execute(), Eigenvalue::execute(), and TransientBase::incrementStepOrReject().

{
  // reset cycle counter
  _cycles_completed = 0;

  if (!_adaptivity.isAdaptivityDue())
    return false;

  TIME_SECTION("adaptMesh", 3, "Adapting Mesh");

  unsigned int cycles_per_step = _adaptivity.getCyclesPerStep();

  bool mesh_changed = false;

  for (unsigned int i = 0; i < cycles_per_step; ++i)
  {
    if (!_mesh.interiorLowerDBlocks().empty() || !_mesh.boundaryLowerDBlocks().empty())
      mooseError("HFEM does not support mesh adaptivity currently.");

    // Markers were already computed once by Executioner
    if (_adaptivity.getRecomputeMarkersFlag() && i > 0)
      computeMarkers();

    bool mesh_changed_this_step;
    mesh_changed_this_step = _adaptivity.adaptMesh();

    if (mesh_changed_this_step)
    {
      mesh_changed = true;

      meshChanged(
          /*intermediate_change=*/true, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
      _cycles_completed++;
    }
    else
    {
      // If the mesh didn't change, we still need to update the displaced mesh
      // to undo the undisplacement performed in Adaptivity::adaptMesh
      if (_displaced_problem)
        _displaced_problem->updateMesh();

      _console << "Mesh unchanged, skipping remaining steps..." << std::endl;
      break;
    }

    // Show adaptivity progress
    _console << std::flush;
  }

  // We're done with all intermediate changes; now get systems ready
  // for real if necessary.
  if (mesh_changed)
    es().reinit_systems();

  // Execute multi-apps that need to run after adaptivity, but before the next timestep.
  execMultiApps(EXEC_POST_ADAPTIVITY);

  return mesh_changed;
}

addAlgebraicGhostingFunctor()

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

inherited

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

Definition at line 1024 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);
}

addAuxArrayVariable()

void FEProblemBase::addAuxArrayVariable ( const std::string &  var_name, const libMesh::FEType &  type, unsigned int  components, const std::set< SubdomainID > *const  active_subdomains = NULL  )

virtualinherited

Definition at line 3271 of file FEProblemBase.C.

{
  parallel_object_only();

  mooseDeprecated("Please use the addAuxVariable(var_type, var_name, params) API instead");

  if (duplicateVariableCheck(var_name, type, /* is_aux = */ true, active_subdomains))
    return;

  InputParameters params = _factory.getValidParams("ArrayMooseVariable");
  params.set<FEProblemBase *>("_fe_problem_base") = this;
  params.set<Moose::VarKindType>("_var_kind") = Moose::VarKindType::VAR_AUXILIARY;
  params.set<MooseEnum>("order") = type.order.get_order();
  params.set<MooseEnum>("family") = Moose::stringify(type.family);
  params.set<unsigned int>("components") = components;

  if (active_subdomains)
    for (const SubdomainID & id : *active_subdomains)
      params.set<std::vector<SubdomainName>>("block").push_back(Moose::stringify(id));

  logAdd("Variable", var_name, "ArrayMooseVariable", params);
  _aux->addVariable("ArrayMooseVariable", var_name, params);
  if (_displaced_problem)
    _displaced_problem->addAuxVariable("ArrayMooseVariable", var_name, params);

  markFamilyPRefinement(params);
}

addAuxKernel()

void MFEMProblem::addAuxKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

overridevirtual

Override of ExternalProblem::addAuxKernel.

Uses ExternalProblem::addAuxKernel to create a MFEMGeneralUserObject representing the kernel in MOOSE, and creates corresponding MFEM kernel to be used in the MFEM solve.

Reimplemented from FEProblemBase.

Definition at line 216 of file MFEMProblem.C.

{
  FEProblemBase::addUserObject(kernel_name, name, parameters);
}

addAuxScalarKernel()

void FEProblemBase::addAuxScalarKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 3349 of file FEProblemBase.C.

{
  parallel_object_only();

  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow AuxScalarKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this AuxScalarKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }

    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _aux.get();
  }

  logAdd("AuxScalarKernel", name, kernel_name, parameters);
  _aux->addScalarKernel(kernel_name, name, parameters);
}

addAuxScalarVariable()

void FEProblemBase::addAuxScalarVariable ( const std::string &  var_name, libMesh::Order  order, Real  scale_factor = 1., const std::set< SubdomainID > *const  active_subdomains = NULL  )

virtualinherited

Definition at line 3303 of file FEProblemBase.C.

{
  parallel_object_only();

  mooseDeprecated("Please use the addAuxVariable(var_type, var_name, params) API instead");

  if (order > _max_scalar_order)
    _max_scalar_order = order;

  FEType type(order, SCALAR);
  if (duplicateVariableCheck(var_name, type, /* is_aux = */ true, active_subdomains))
    return;

  InputParameters params = _factory.getValidParams("MooseVariableScalar");
  params.set<FEProblemBase *>("_fe_problem_base") = this;
  params.set<Moose::VarKindType>("_var_kind") = Moose::VarKindType::VAR_AUXILIARY;

  params.set<MooseEnum>("order") = type.order.get_order();
  params.set<MooseEnum>("family") = "SCALAR";
  params.set<std::vector<Real>>("scaling") = {1};
  if (active_subdomains)
    for (const SubdomainID & id : *active_subdomains)
      params.set<std::vector<SubdomainName>>("block").push_back(Moose::stringify(id));

  logAdd("ScalarVariable", var_name, "MooseVariableScalar", params);
  _aux->addVariable("MooseVariableScalar", var_name, params);
  if (_displaced_problem)
    _displaced_problem->addAuxVariable("MooseVariableScalar", var_name, params);
}

addAuxVariable() [1/2]

void MFEMProblem::addAuxVariable ( const std::string &  var_type, const std::string &  var_name, InputParameters &  parameters  )

overridevirtual

Override of ExternalProblem::addAuxVariable.

Sets a MFEM grid function to be used in the MFEM solve.

Reimplemented from FEProblemBase.

Definition at line 206 of file MFEMProblem.C.

{
  // We handle MFEM AuxVariables just like MFEM Variables, except
  // we do not add additional GridFunctions for time derivatives.
  addGridFunction(var_type, var_name, parameters);
}

addAuxVariable() [2/2]

void FEProblemBase::addAuxVariable ( const std::string &  var_name, const libMesh::FEType &  type, const std::set< SubdomainID > *const  active_subdomains = NULL  )

virtualinherited

Definition at line 3231 of file FEProblemBase.C.

{
  parallel_object_only();

  mooseDeprecated("Please use the addAuxVariable(var_type, var_name, params) API instead");

  if (duplicateVariableCheck(var_name, type, /* is_aux = */ true, active_subdomains))
    return;

  std::string var_type;
  if (type == FEType(0, MONOMIAL))
    var_type = "MooseVariableConstMonomial";
  else if (type.family == SCALAR)
    var_type = "MooseVariableScalar";
  else if (FEInterface::field_type(type) == TYPE_VECTOR)
    var_type = "VectorMooseVariable";
  else
    var_type = "MooseVariable";

  InputParameters params = _factory.getValidParams(var_type);
  params.set<FEProblemBase *>("_fe_problem_base") = this;
  params.set<Moose::VarKindType>("_var_kind") = Moose::VarKindType::VAR_AUXILIARY;
  params.set<MooseEnum>("order") = type.order.get_order();
  params.set<MooseEnum>("family") = Moose::stringify(type.family);

  if (active_subdomains)
    for (const SubdomainID & id : *active_subdomains)
      params.set<std::vector<SubdomainName>>("block").push_back(Moose::stringify(id));

  logAdd("AuxVariable", var_name, var_type, params);
  _aux->addVariable(var_type, var_name, params);
  if (_displaced_problem)
    _displaced_problem->addAuxVariable("MooseVariable", var_name, params);

  markFamilyPRefinement(params);
}

addBoundaryCondition()

void MFEMProblem::addBoundaryCondition ( const std::string &  bc_name, const std::string &  name, InputParameters &  parameters  )

overridevirtual

Reimplemented from FEProblemBase.

Definition at line 92 of file MFEMProblem.C.

{
  FEProblemBase::addUserObject(bc_name, name, parameters);
  const UserObject * mfem_bc_uo = &(getUserObjectBase(name));
  if (dynamic_cast<const MFEMIntegratedBC *>(mfem_bc_uo) != nullptr)
  {
    auto object_ptr = getUserObject<MFEMIntegratedBC>(name).getSharedPtr();
    auto bc = std::dynamic_pointer_cast<MFEMIntegratedBC>(object_ptr);
    if (getProblemData().eqn_system)
    {
      getProblemData().eqn_system->AddIntegratedBC(std::move(bc));
    }
    else
    {
      mooseError("Cannot add integrated BC with name '" + name +
                 "' because there is no corresponding equation system.");
    }
  }
  else if (dynamic_cast<const MFEMEssentialBC *>(mfem_bc_uo) != nullptr)
  {
    auto object_ptr = getUserObject<MFEMEssentialBC>(name).getSharedPtr();
    auto mfem_bc = std::dynamic_pointer_cast<MFEMEssentialBC>(object_ptr);
    if (getProblemData().eqn_system)
    {
      getProblemData().eqn_system->AddEssentialBC(std::move(mfem_bc));
    }
    else
    {
      mooseError("Cannot add boundary condition with name '" + name +
                 "' because there is no corresponding equation system.");
    }
  }
  else
  {
    mooseError("Unsupported bc of type '", bc_name, "' and name '", name, "' detected.");
  }
}

addCachedJacobian()

void FEProblemBase::addCachedJacobian ( const THREAD_ID  tid )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2043 of file FEProblemBase.C.

Referenced by ComputeResidualAndJacobianThread::accumulate(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::enforceNodalConstraintsJacobian(), ComputeNodalKernelBCJacobiansThread::onNode(), ComputeNodalKernelJacobiansThread::onNode(), and ComputeJacobianThread::postElement().

{
  SubProblem::addCachedJacobian(tid);
  if (_displaced_problem)
    _displaced_problem->addCachedJacobian(tid);
}

addCachedResidual()

void FEProblemBase::addCachedResidual ( const THREAD_ID  tid )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 1929 of file FEProblemBase.C.

Referenced by ComputeResidualThread::accumulate(), ComputeResidualAndJacobianThread::accumulate(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::constraintResiduals(), ComputeNodalKernelBcsThread::onNode(), and ComputeNodalKernelsThread::onNode().

{
  SubProblem::addCachedResidual(tid);
  if (_displaced_problem)
    _displaced_problem->addCachedResidual(tid);
}

addCachedResidualDirectly()

void FEProblemBase::addCachedResidualDirectly ( NumericVector< libMesh::Number > &  residual, const THREAD_ID  tid  )

virtualinherited

Allows for all the residual contributions that are currently cached to be added directly into the vector passed in.

Parameters

residual	The vector to add the cached contributions to.
tid	The thread id.

Definition at line 1937 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintResiduals(), and NonlinearSystemBase::enforceNodalConstraintsResidual().

{
  if (_current_nl_sys->hasVector(_current_nl_sys->timeVectorTag()))
    _assembly[tid][_current_nl_sys->number()]->addCachedResidualDirectly(
        residual, Assembly::GlobalDataKey{}, getVectorTag(_current_nl_sys->timeVectorTag()));

  if (_current_nl_sys->hasVector(_current_nl_sys->nonTimeVectorTag()))
    _assembly[tid][_current_nl_sys->number()]->addCachedResidualDirectly(
        residual, Assembly::GlobalDataKey{}, getVectorTag(_current_nl_sys->nonTimeVectorTag()));

  // We do this because by adding the cached residual directly, we cannot ensure that all of the
  // cached residuals are emptied after only the two add calls above
  _assembly[tid][_current_nl_sys->number()]->clearCachedResiduals(Assembly::GlobalDataKey{});

  if (_displaced_problem)
    _displaced_problem->addCachedResidualDirectly(residual, tid);
}

addConstraint()

void FEProblemBase::addConstraint ( const std::string &  c_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 3147 of file FEProblemBase.C.

{
  parallel_object_only();

  _has_constraints = true;

  auto determine_var_param_name = [&parameters, this]()
  {
    if (parameters.isParamValid("variable"))
      return "variable";
    else
    {
      // must be a mortar constraint
      const bool has_secondary_var = parameters.isParamValid("secondary_variable");
      const bool has_primary_var = parameters.isParamValid("primary_variable");
      if (!has_secondary_var && !has_primary_var)
        mooseError(
            "Either a 'secondary_variable' or 'primary_variable' parameter must be supplied for '",
            parameters.getObjectName(),
            "'");
      return has_secondary_var ? "secondary_variable" : "primary_variable";
    }
  };

  const auto nl_sys_num =
      determineSolverSystem(parameters.varName(determine_var_param_name(), name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a Constraint to a linear variable/system, which is not "
               "supported at the moment!");

  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
    _reinit_displaced_face = true;
  }
  else
  {
    // It might _want_ to use a displaced mesh... but we're not so set it to false
    if (parameters.have_parameter<bool>("use_displaced_mesh"))
      parameters.set<bool>("use_displaced_mesh") = false;

    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }

  logAdd("Constraint", name, c_name, parameters);
  _nl[nl_sys_num]->addConstraint(c_name, name, parameters);
}

addConsumedPropertyName()

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

inherited

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

Definition at line 737 of file SubProblem.C.

Referenced by MaterialPropertyInterface::addConsumedPropertyName().

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

addConvergence()

void FEProblemBase::addConvergence ( const std::string &  type, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Adds a Convergence object.

Definition at line 2568 of file FEProblemBase.C.

Referenced by FEProblemBase::addDefaultMultiAppFixedPointConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), and FEProblemBase::addDefaultSteadyStateConvergence().

{
  parallel_object_only();

  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    std::shared_ptr<Convergence> conv = _factory.create<Convergence>(type, name, parameters, tid);
    _convergences.addObject(conv, tid);
  }
}

addCouplingGhostingFunctor()

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

inherited

Add a coupling functor to this problem's DofMaps.

Definition at line 1057 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);
}

addDamper()

void FEProblemBase::addDamper ( const std::string &  damper_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 5365 of file FEProblemBase.C.

{
  parallel_object_only();

  const auto nl_sys_num =
      parameters.isParamValid("variable")
          ? determineSolverSystem(parameters.varName("variable", name), true).second
          : (unsigned int)0;

  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a DGKernel to a linear variable/system, which is not "
               "supported at the moment!");

  parameters.set<SubProblem *>("_subproblem") = this;
  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();

  _has_dampers = true;
  logAdd("Damper", name, damper_name, parameters);
  _nl[nl_sys_num]->addDamper(damper_name, name, parameters);
}

addDefaultMultiAppFixedPointConvergence()

void FEProblemBase::addDefaultMultiAppFixedPointConvergence ( const InputParameters &  params )

inherited

Adds the default fixed point Convergence associated with the problem.

This is called if the user does not supply 'multiapp_fixed_point_convergence'.

Parameters

[in]

params

Parameters to apply to Convergence parameters

Definition at line 2594 of file FEProblemBase.C.

{
  const std::string class_name = "DefaultMultiAppFixedPointConvergence";
  InputParameters params = _factory.getValidParams(class_name);
  params.applyParameters(params_to_apply);
  params.applyParameters(parameters());
  params.set<bool>("added_as_default") = true;
  addConvergence(class_name, getMultiAppFixedPointConvergenceName(), params);
}

addDefaultNonlinearConvergence()

void FEProblemBase::addDefaultNonlinearConvergence ( const InputParameters &  params )

virtualinherited

Adds the default nonlinear Convergence associated with the problem.

This is called if the user does not supply 'nonlinear_convergence'.

Parameters

[in]

params

Parameters to apply to Convergence parameters

Reimplemented in ReferenceResidualProblem.

Definition at line 2582 of file FEProblemBase.C.

{
  const std::string class_name = "DefaultNonlinearConvergence";
  InputParameters params = _factory.getValidParams(class_name);
  params.applyParameters(params_to_apply);
  params.applyParameters(parameters());
  params.set<bool>("added_as_default") = true;
  for (const auto & conv_name : getNonlinearConvergenceNames())
    addConvergence(class_name, conv_name, params);
}

addDefaultSteadyStateConvergence()

void FEProblemBase::addDefaultSteadyStateConvergence ( const InputParameters &  params )

inherited

Adds the default steady-state detection Convergence.

This is called if the user does not supply 'steady_state_convergence'.

Parameters

[in]

params

Parameters to apply to Convergence parameters

Definition at line 2605 of file FEProblemBase.C.

{
  const std::string class_name = "DefaultSteadyStateConvergence";
  InputParameters params = _factory.getValidParams(class_name);
  params.applyParameters(params_to_apply);
  params.applyParameters(parameters());
  params.set<bool>("added_as_default") = true;
  addConvergence(class_name, getSteadyStateConvergenceName(), params);
}

addDGKernel()

void FEProblemBase::addDGKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 3421 of file FEProblemBase.C.

{
  parallel_object_only();

  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a DGKernel to a linear variable/system, which is not "
               "supported at the moment!");

  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
    _reinit_displaced_neighbor = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow DGKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this DGKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }

    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }

  logAdd("DGKernel", name, dg_kernel_name, parameters);
  _nl[nl_sys_num]->addDGKernel(dg_kernel_name, name, parameters);

  _has_internal_edge_residual_objects = true;
}

addDiracKernel()

void FEProblemBase::addDiracKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 3381 of file FEProblemBase.C.

{
  parallel_object_only();

  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a DiracKernel to a linear variable/system, which is not "
               "supported at the moment!");

  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
    _reinit_displaced_elem = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow DiracKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this DiracKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }

    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }

  logAdd("DiracKernel", name, kernel_name, parameters);
  _nl[nl_sys_num]->addDiracKernel(kernel_name, name, parameters);
}

addDisplacedProblem()

void FEProblemBase::addDisplacedProblem ( std::shared_ptr< DisplacedProblem >  displaced_problem )

virtualinherited

Definition at line 8011 of file FEProblemBase.C.

{
  parallel_object_only();

  _displaced_mesh = &displaced_problem->mesh();
  _displaced_problem = displaced_problem;
}

addDistribution()

void FEProblemBase::addDistribution ( const std::string &  type, const std::string &  name, InputParameters &  parameters  )

virtualinherited

The following functions will enable MOOSE to have the capability to import distributions.

Definition at line 2734 of file FEProblemBase.C.

{
  parameters.set<std::string>("type") = type;
  addObject<Distribution>(type, name, parameters, /* threaded = */ false);
}

addExternalVariables()

virtual void ExternalProblem::addExternalVariables ( )

inlinevirtualinherited

Method called to add AuxVariables to the simulation.

These variables would be the fields that should either be saved out with the MOOSE-formatted solutions or available for transfer to variables in Multiapp simulations.

Definition at line 48 of file ExternalProblem.h.

Referenced by AddExternalAuxVariableAction::act().

{}

addFESpace()

void MFEMProblem::addFESpace	(	const std::string &	user_object_name,
		const std::string &	name,
		InputParameters &	parameters
	)

Add an MFEM FESpace to the problem.

Definition at line 149 of file MFEMProblem.C.

Referenced by AddMFEMFESpaceAction::act(), and addMFEMFESpaceFromMOOSEVariable().

{
  FEProblemBase::addUserObject(user_object_name, name, parameters);
  MFEMFESpace & mfem_fespace(getUserObject<MFEMFESpace>(name));

  // Register fespace and associated fe collection.
  getProblemData().fecs.Register(name, mfem_fespace.getFEC());
  getProblemData().fespaces.Register(name, mfem_fespace.getFESpace());
}

addFunction()

void MFEMProblem::addFunction ( const std::string &  type, const std::string &  name, InputParameters &  parameters  )

overridevirtual

Override of ExternalProblem::addFunction.

Uses ExternalProblem::addFunction to create a MFEMGeneralUserObject representing the function in MOOSE, and creates a corresponding MFEM Coefficient or VectorCoefficient object.

Reimplemented from FEProblemBase.

Definition at line 327 of file MFEMProblem.C.

{
  ExternalProblem::addFunction(type, name, parameters);
  auto & func = getFunction(name);
  // FIXME: Do we want to have optimised versions for when functions
  // are only of space or only of time.
  if (std::find(SCALAR_FUNCS.begin(), SCALAR_FUNCS.end(), type) != SCALAR_FUNCS.end())
  {
    getCoefficients().declareScalar<mfem::FunctionCoefficient>(
        name,
        [&func](const mfem::Vector & p, mfem::real_t t) -> mfem::real_t
        { return func.value(t, pointFromMFEMVector(p)); });
  }
  else if (std::find(VECTOR_FUNCS.begin(), VECTOR_FUNCS.end(), type) != VECTOR_FUNCS.end())
  {
    int dim = vectorFunctionDim(type, parameters);
    getCoefficients().declareVector<mfem::VectorFunctionCoefficient>(
        name,
        dim,
        [&func, dim](const mfem::Vector & p, mfem::real_t t, mfem::Vector & u)
        {
          libMesh::RealVectorValue vector_value = func.vectorValue(t, pointFromMFEMVector(p));
          for (int i = 0; i < dim; i++)
          {
            u[i] = vector_value(i);
          }
        });
  }
  else
  {
    mooseWarning("Could not identify whether function ",
                 type,
                 " is scalar or vector; no MFEM coefficient object created.");
  }
}

addFunctor()

template<typename T >

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

inherited

add a functor to the problem functor container

Definition at line 1380 of file SubProblem.h.

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

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

addFunctorMaterial()

void MFEMProblem::addFunctorMaterial ( const std::string &  material_name, const std::string &  name, InputParameters &  parameters  )

overridevirtual

Reimplemented from FEProblemBase.

Definition at line 140 of file MFEMProblem.C.

{
  FEProblemBase::addUserObject(material_name, name, parameters);
  getUserObject<MFEMFunctorMaterial>(name);
}

addFVBC()

void FEProblemBase::addFVBC ( const std::string &  fv_bc_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 3475 of file FEProblemBase.C.

Referenced by DiffusionFV::addFVBCs().

{
  addObject<FVBoundaryCondition>(fv_bc_name, name, parameters);
}

addFVInitialCondition()

void FEProblemBase::addFVInitialCondition ( const std::string &  ic_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Add an initial condition for a finite volume variables.

Parameters

ic_name	The name of the boundary condition object
name	The user-defined name from the input file
parameters	The input parameters for construction

Definition at line 3644 of file FEProblemBase.C.

{
  parallel_object_only();

  // before we start to mess with the initial condition, we need to check parameters for errors.
  parameters.checkParams(name);
  const std::string & var_name = parameters.get<VariableName>("variable");

  // Forbid initial conditions on a restarted problem, as they would override the restart
  checkICRestartError(ic_name, name, var_name);

  parameters.set<SubProblem *>("_subproblem") = this;

  // field IC
  if (hasVariable(var_name))
  {
    for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
    {
      auto & var = getVariable(
          tid, var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY);
      parameters.set<SystemBase *>("_sys") = &var.sys();
      std::shared_ptr<FVInitialConditionBase> ic;
      if (var.isFV())
        ic = _factory.create<FVInitialCondition>(ic_name, name, parameters, tid);
      else
        mooseError(
            "Your variable for an FVInitialCondition needs to be an a finite volume variable!");
      _fv_ics.addObject(ic, tid);
    }
  }
  else
    mooseError("Variable '",
               var_name,
               "' requested in finite volume initial condition '",
               name,
               "' does not exist.");
}

addFVInterfaceKernel()

void FEProblemBase::addFVInterfaceKernel ( const std::string &  fv_ik_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

We assume that variable1 and variable2 can live on different systems, in this case the user needs to create two interface kernels with flipped variables and parameters

Definition at line 3483 of file FEProblemBase.C.

{
  addObject<FVInterfaceKernel>(
      fv_ik_name, name, parameters, /*threaded=*/true, /*variable_param_name=*/"variable1");
}

addFVKernel()

void FEProblemBase::addFVKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 3461 of file FEProblemBase.C.

Referenced by DiffusionFV::addFVKernels().

{
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
    // FVElementalKernels are computed in the historically finite element threaded loops. They rely
    // on Assembly data like _current_elem. When we call reinit on the FEProblemBase we will only
    // reinit the DisplacedProblem and its associated Assembly objects if we mark this boolean as
    // true
    _reinit_displaced_elem = true;
  addObject<FVKernel>(fv_kernel_name, name, parameters);
}

addGhostedBoundary()

void FEProblemBase::addGhostedBoundary ( BoundaryID  boundary_id )

overridevirtualinherited

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

Implements SubProblem.

Definition at line 2139 of file FEProblemBase.C.

Referenced by DisplacedProblem::addGhostedBoundary().

{
  _mesh.addGhostedBoundary(boundary_id);
  if (_displaced_problem)
    _displaced_mesh->addGhostedBoundary(boundary_id);
}

addGhostedElem()

void FEProblemBase::addGhostedElem ( dof_id_type  elem_id )

overridevirtualinherited

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

Implements SubProblem.

Definition at line 2132 of file FEProblemBase.C.

Referenced by DisplacedProblem::addGhostedElem(), and NodalPatchRecovery::NodalPatchRecovery().

{
  if (_mesh.elemPtr(elem_id)->processor_id() != processor_id())
    _ghosted_elems.insert(elem_id);
}

addGridFunction()

void MFEMProblem::addGridFunction	(	const std::string &	var_type,
		const std::string &	var_name,
		InputParameters &	parameters
	)

Adds one MFEM GridFunction to be used in the MFEM solve.

Definition at line 175 of file MFEMProblem.C.

Referenced by addAuxVariable(), and addVariable().

{
  if (var_type == "MFEMVariable")
  {
    // Add MFEM variable directly.
    FEProblemBase::addUserObject(var_type, var_name, parameters);
  }
  else
  {
    // Add MOOSE variable.
    FEProblemBase::addVariable(var_type, var_name, parameters);

    // Add MFEM variable indirectly ("gridfunction").
    InputParameters mfem_variable_params = addMFEMFESpaceFromMOOSEVariable(parameters);
    FEProblemBase::addUserObject("MFEMVariable", var_name, mfem_variable_params);
  }

  // Register gridfunction.
  MFEMVariable & mfem_variable = getUserObject<MFEMVariable>(var_name);
  getProblemData().gridfunctions.Register(var_name, mfem_variable.getGridFunction());
  if (mfem_variable.getFESpace().isScalar())
    getCoefficients().declareScalar<mfem::GridFunctionCoefficient>(
        var_name, mfem_variable.getGridFunction().get());
  else
    getCoefficients().declareVector<mfem::VectorGridFunctionCoefficient>(
        var_name, mfem_variable.getGridFunction().get());
}

addHDGKernel()

void FEProblemBase::addHDGKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 3043 of file FEProblemBase.C.

{
  parallel_object_only();
  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a HDGKernel to a linear variable/system, which is not "
               "supported at the moment!");
  setResidualObjectParamsAndLog(
      kernel_name, name, parameters, nl_sys_num, "HDGKernel", _reinit_displaced_elem);

  _nl[nl_sys_num]->addHDGKernel(kernel_name, name, parameters);
}

addIndicator()

void FEProblemBase::addIndicator ( const std::string &  indicator_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 5396 of file FEProblemBase.C.

{
  parallel_object_only();

  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
    _reinit_displaced_elem = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow Indicators to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this Indicator.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }

    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _aux.get();
  }

  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    std::shared_ptr<Indicator> indicator =
        _factory.create<Indicator>(indicator_name, name, parameters, tid);
    logAdd("Indicator", name, indicator_name, parameters);
    std::shared_ptr<InternalSideIndicatorBase> isi =
        std::dynamic_pointer_cast<InternalSideIndicatorBase>(indicator);
    if (isi)
      _internal_side_indicators.addObject(isi, tid);
    else
      _indicators.addObject(indicator, tid);
  }
}

addInitialCondition()

void MFEMProblem::addInitialCondition ( const std::string &  ic_name, const std::string &  name, InputParameters &  parameters  )

overridevirtual

Reimplemented from FEProblemBase.

Definition at line 509 of file MFEMProblem.C.

{
  FEProblemBase::addUserObject(ic_name, name, parameters);
  getUserObject<MFEMInitialCondition>(name); // error check
}

addInterfaceKernel()

void FEProblemBase::addInterfaceKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 3512 of file FEProblemBase.C.

{
  parallel_object_only();

  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a InterfaceKernel to a linear variable/system, which is not "
               "supported at the moment!");

  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
    _reinit_displaced_neighbor = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow InterfaceKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this InterfaceKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }

    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }

  logAdd("InterfaceKernel", name, interface_kernel_name, parameters);
  _nl[nl_sys_num]->addInterfaceKernel(interface_kernel_name, name, parameters);

  _has_internal_edge_residual_objects = true;
}

addInterfaceMaterial()

void FEProblemBase::addInterfaceMaterial ( const std::string &  material_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 4008 of file FEProblemBase.C.

{
  addMaterialHelper({&_interface_materials}, mat_name, name, parameters);
}

addJacobian()

void FEProblemBase::addJacobian ( const THREAD_ID  tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1976 of file FEProblemBase.C.

Referenced by ComputeDiracThread::postElement().

{
  _assembly[tid][_current_nl_sys->number()]->addJacobian(Assembly::GlobalDataKey{});
  if (_has_nonlocal_coupling)
    _assembly[tid][_current_nl_sys->number()]->addJacobianNonlocal(Assembly::GlobalDataKey{});
  if (_displaced_problem)
  {
    _displaced_problem->addJacobian(tid);
    if (_has_nonlocal_coupling)
      _displaced_problem->addJacobianNonlocal(tid);
  }
}

addJacobianBlockTags()

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

virtualinherited

Definition at line 2051 of file FEProblemBase.C.

Referenced by ComputeJacobianBlocksThread::postElement().

{
  _assembly[tid][_current_nl_sys->number()]->addJacobianBlockTags(
      jacobian, ivar, jvar, dof_map, dof_indices, Assembly::GlobalDataKey{}, tags);

  if (_has_nonlocal_coupling)
    if (_nonlocal_cm[_current_nl_sys->number()](ivar, jvar) != 0)
    {
      MooseVariableFEBase & jv = _current_nl_sys->getVariable(tid, jvar);
      _assembly[tid][_current_nl_sys->number()]->addJacobianBlockNonlocalTags(
          jacobian,
          ivar,
          jvar,
          dof_map,
          dof_indices,
          jv.allDofIndices(),
          Assembly::GlobalDataKey{},
          tags);
    }

  if (_displaced_problem)
  {
    _displaced_problem->addJacobianBlockTags(jacobian, ivar, jvar, dof_map, dof_indices, tags, tid);
    if (_has_nonlocal_coupling)
      if (_nonlocal_cm[_current_nl_sys->number()](ivar, jvar) != 0)
      {
        MooseVariableFEBase & jv = _current_nl_sys->getVariable(tid, jvar);
        _displaced_problem->addJacobianBlockNonlocal(
            jacobian, ivar, jvar, dof_map, dof_indices, jv.allDofIndices(), tags, tid);
      }
  }
}

addJacobianLowerD()

void FEProblemBase::addJacobianLowerD ( const THREAD_ID  tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 2006 of file FEProblemBase.C.

Referenced by ComputeResidualAndJacobianThread::accumulateLower(), and ComputeJacobianThread::accumulateLower().

{
  _assembly[tid][_current_nl_sys->number()]->addJacobianLowerD(Assembly::GlobalDataKey{});
  if (_displaced_problem)
    _displaced_problem->addJacobianLowerD(tid);
}

addJacobianNeighbor() [1/3]

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 virtualinherited

Implemented in DisplacedProblem.

addJacobianNeighbor() [2/3]

void FEProblemBase::addJacobianNeighbor ( const THREAD_ID  tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1990 of file FEProblemBase.C.

Referenced by ComputeResidualAndJacobianThread::accumulateNeighbor(), ComputeJacobianThread::accumulateNeighbor(), and ComputeJacobianBlocksThread::postInternalSide().

{
  _assembly[tid][_current_nl_sys->number()]->addJacobianNeighbor(Assembly::GlobalDataKey{});
  if (_displaced_problem)
    _displaced_problem->addJacobianNeighbor(tid);
}

addJacobianNeighbor() [3/3]

virtual void FEProblemBase::addJacobianNeighbor ( libMesh::SparseMatrix< libMesh::Number > &  jacobian, unsigned int  ivar, unsigned int  jvar, const 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  )

overridevirtualinherited

addJacobianNeighborLowerD()

void FEProblemBase::addJacobianNeighborLowerD ( const THREAD_ID  tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1998 of file FEProblemBase.C.

Referenced by ComputeResidualAndJacobianThread::accumulateNeighborLower(), and ComputeJacobianThread::accumulateNeighborLower().

{
  _assembly[tid][_current_nl_sys->number()]->addJacobianNeighborLowerD(Assembly::GlobalDataKey{});
  if (_displaced_problem)
    _displaced_problem->addJacobianNeighborLowerD(tid);
}

addJacobianOffDiagScalar()

void FEProblemBase::addJacobianOffDiagScalar ( unsigned int  ivar, const THREAD_ID  tid = 0  )

virtualinherited

Definition at line 2020 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians().

{
  _assembly[tid][_current_nl_sys->number()]->addJacobianOffDiagScalar(ivar,
                                                                      Assembly::GlobalDataKey{});
}

addJacobianScalar()

void FEProblemBase::addJacobianScalar ( const THREAD_ID  tid = 0 )

virtualinherited

Definition at line 2014 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians().

{
  _assembly[tid][_current_nl_sys->number()]->addJacobianScalar(Assembly::GlobalDataKey{});
}

addKernel()

void MFEMProblem::addKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

overridevirtual

Override of ExternalProblem::addKernel.

Uses ExternalProblem::addKernel to create a MFEMGeneralUserObject representing the kernel in MOOSE, and creates corresponding MFEM kernel to be used in the MFEM solve.

Reimplemented from FEProblemBase.

Definition at line 224 of file MFEMProblem.C.

{
  FEProblemBase::addUserObject(kernel_name, name, parameters);
  const UserObject * kernel_uo = &(getUserObjectBase(name));

  if (dynamic_cast<const MFEMKernel *>(kernel_uo) != nullptr)
  {
    auto object_ptr = getUserObject<MFEMKernel>(name).getSharedPtr();
    auto kernel = std::dynamic_pointer_cast<MFEMKernel>(object_ptr);
    if (getProblemData().eqn_system)
    {
      getProblemData().eqn_system->AddKernel(std::move(kernel));
    }
    else
    {
      mooseError("Cannot add kernel with name '" + name +
                 "' because there is no corresponding equation system.");
    }
  }
  else
  {
    mooseError("Unsupported kernel of type '", kernel_name, "' and name '", name, "' detected.");
  }
}

addKokkosAuxKernel()

virtual void FEProblemBase::addKokkosAuxKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

addKokkosBoundaryCondition()

virtual void FEProblemBase::addKokkosBoundaryCondition ( const std::string &  bc_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

addKokkosKernel()

virtual void FEProblemBase::addKokkosKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

addKokkosMaterial()

virtual void FEProblemBase::addKokkosMaterial ( const std::string &  material_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

addKokkosNodalKernel()

virtual void FEProblemBase::addKokkosNodalKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

addLinearFVBC()

void FEProblemBase::addLinearFVBC ( const std::string &  fv_bc_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 3502 of file FEProblemBase.C.

{
  addObject<LinearFVBoundaryCondition>(bc_name, name, parameters);
}

addLinearFVKernel()

void FEProblemBase::addLinearFVKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 3494 of file FEProblemBase.C.

{
  addObject<LinearFVKernel>(kernel_name, name, parameters);
}

addLineSearch()

virtual void FEProblemBase::addLineSearch ( const InputParameters &  )

inlinevirtualinherited

add a MOOSE line search

Reimplemented in DumpObjectsProblem, and FEProblem.

Definition at line 739 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

  {
    mooseError("Line search not implemented for this problem type yet.");
  }

addMarker()

void FEProblemBase::addMarker ( const std::string &  marker_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 5439 of file FEProblemBase.C.

{
  parallel_object_only();

  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
    _reinit_displaced_elem = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow Markers to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this Marker.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }

    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _aux.get();
  }

  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    std::shared_ptr<Marker> marker = _factory.create<Marker>(marker_name, name, parameters, tid);
    logAdd("Marker", name, marker_name, parameters);
    _markers.addObject(marker, tid);
  }
}

addMaterial()

void MFEMProblem::addMaterial ( const std::string &  material_name, const std::string &  name, InputParameters &  parameters  )

overridevirtual

Reimplemented from FEProblemBase.

Definition at line 133 of file MFEMProblem.C.

{
  mooseError(
      "MFEM materials must be added through the 'FunctorMaterials' block and not 'Materials'");
}

addMaterialHelper()

void FEProblemBase::addMaterialHelper ( std::vector< MaterialWarehouse *>  warehouse, const std::string &  material_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 4016 of file FEProblemBase.C.

Referenced by FEProblemBase::addInterfaceMaterial(), and FEProblemBase::addMaterial().

{
  parallel_object_only();

  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    _reinit_displaced_elem = _reinit_displaced_face = _reinit_displaced_neighbor = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow Materials to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this Material.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }

    parameters.set<SubProblem *>("_subproblem") = this;
  }

  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    // Create the general Block/Boundary MaterialBase object
    std::shared_ptr<MaterialBase> material =
        _factory.create<MaterialBase>(mat_name, name, parameters, tid);
    logAdd("Material", name, mat_name, parameters);
    bool discrete = !material->getParam<bool>("compute");

    // If the object is boundary restricted or if it is a functor material we do not create the
    // neighbor and face objects
    if (material->boundaryRestricted() || dynamic_cast<FunctorMaterial *>(material.get()))
    {
      _all_materials.addObject(material, tid);
      if (discrete)
        _discrete_materials.addObject(material, tid);
      else
        for (auto && warehouse : warehouses)
          warehouse->addObject(material, tid);
    }

    // Non-boundary restricted require face and neighbor objects
    else
    {
      // TODO: we only need to do this if we have needs for face materials (e.g.
      // FV, DG, etc.) - but currently we always do it.  Figure out how to fix
      // this.

      // The name of the object being created, this is changed multiple times as objects are
      // created below
      std::string object_name;

      // Create a copy of the supplied parameters to the setting for "_material_data_type" isn't
      // used from a previous tid loop
      InputParameters current_parameters = parameters;

      // face material
      current_parameters.set<Moose::MaterialDataType>("_material_data_type") =
          Moose::FACE_MATERIAL_DATA;
      object_name = name + "_face";
      std::shared_ptr<MaterialBase> face_material =
          _factory.create<MaterialBase>(mat_name, object_name, current_parameters, tid);

      // neighbor material
      current_parameters.set<Moose::MaterialDataType>("_material_data_type") =
          Moose::NEIGHBOR_MATERIAL_DATA;
      current_parameters.set<bool>("_neighbor") = true;
      object_name = name + "_neighbor";
      std::shared_ptr<MaterialBase> neighbor_material =
          _factory.create<MaterialBase>(mat_name, object_name, current_parameters, tid);

      // Store the material objects
      _all_materials.addObjects(material, neighbor_material, face_material, tid);

      if (discrete)
        _discrete_materials.addObjects(material, neighbor_material, face_material, tid);
      else
        for (auto && warehouse : warehouses)
          warehouse->addObjects(material, neighbor_material, face_material, tid);

      // Names of all controllable parameters for this Material object
      const std::string & base = parameters.getBase();
      MooseObjectParameterName name(MooseObjectName(base, material->name()), "*");
      const auto param_names =
          _app.getInputParameterWarehouse().getControllableParameterNames(name);

      // Connect parameters of the primary Material object to those on the face and neighbor
      // objects
      for (const auto & p_name : param_names)
      {
        MooseObjectParameterName primary_name(MooseObjectName(base, material->name()),
                                              p_name.parameter());
        MooseObjectParameterName face_name(MooseObjectName(base, face_material->name()),
                                           p_name.parameter());
        MooseObjectParameterName neighbor_name(MooseObjectName(base, neighbor_material->name()),
                                               p_name.parameter());
        _app.getInputParameterWarehouse().addControllableParameterConnection(
            primary_name, face_name, false);
        _app.getInputParameterWarehouse().addControllableParameterConnection(
            primary_name, neighbor_name, false);
      }
    }
  }
}

addMatrixTag()

TagID SubProblem::addMatrixTag ( TagName  tag_name )

virtualinherited

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 312 of file SubProblem.C.

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

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

addMeshDivision()

void FEProblemBase::addMeshDivision ( const std::string &  type, const std::string &  name, InputParameters &  params  )

virtualinherited

Add a MeshDivision.

Definition at line 2689 of file FEProblemBase.C.

{
  parallel_object_only();
  parameters.set<FEProblemBase *>("_fe_problem_base") = this;
  parameters.set<SubProblem *>("_subproblem") = this;
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
  {
    std::shared_ptr<MeshDivision> func = _factory.create<MeshDivision>(type, name, parameters, tid);
    _mesh_divisions.addObject(func, tid);
  }
}

addMFEMFESpaceFromMOOSEVariable()

InputParameters MFEMProblem::addMFEMFESpaceFromMOOSEVariable

(

InputParameters &

moosevar_params

)

Method used to get an mfem FEC depending on the variable family specified in the input file.

This method is used in addAuxVariable to help create the MFEM grid function that corresponds to a given MOOSE aux-variable.

Definition at line 377 of file MFEMProblem.C.

Referenced by addGridFunction().

{

  InputParameters fespace_params = _factory.getValidParams("MFEMGenericFESpace");
  InputParameters mfem_variable_params = _factory.getValidParams("MFEMVariable");

  auto moose_fe_type =
      FEType(Utility::string_to_enum<Order>(parameters.get<MooseEnum>("order")),
             Utility::string_to_enum<FEFamily>(parameters.get<MooseEnum>("family")));

  std::string mfem_family;
  int mfem_vdim = 1;

  switch (moose_fe_type.family)
  {
    case FEFamily::LAGRANGE:
      mfem_family = "H1";
      mfem_vdim = 1;
      break;
    case FEFamily::LAGRANGE_VEC:
      mfem_family = "H1";
      mfem_vdim = 3;
      break;
    case FEFamily::MONOMIAL:
      mfem_family = "L2";
      mfem_vdim = 1;
      break;
    case FEFamily::MONOMIAL_VEC:
      mfem_family = "L2";
      mfem_vdim = 3;
      break;
    default:
      mooseError("Unable to set MFEM FESpace for MOOSE variable");
      break;
  }

  // Create fespace name. If this already exists, we will reuse this for
  // the mfem variable ("gridfunction").
  const std::string fespace_name = mfem_family + "_" +
                                   std::to_string(mesh().getMFEMParMesh().Dimension()) + "D_P" +
                                   std::to_string(moose_fe_type.order.get_order());

  // Set all fespace parameters.
  fespace_params.set<std::string>("fec_name") = fespace_name;
  fespace_params.set<int>("vdim") = mfem_vdim;

  if (!hasUserObject(fespace_name)) // Create the fespace (implicit).
  {
    addFESpace("MFEMGenericFESpace", fespace_name, fespace_params);
  }

  mfem_variable_params.set<UserObjectName>("fespace") = fespace_name;

  return mfem_variable_params;
}

addMFEMNonlinearSolver()

void MFEMProblem::addMFEMNonlinearSolver

(

)

Add the nonlinear solver to the system.

TODO: allow user to specify solver options, similar to the linear solvers.

Definition at line 79 of file MFEMProblem.C.

Referenced by initialSetup().

{
  auto nl_solver = std::make_shared<mfem::NewtonSolver>(getComm());

  // Defaults to one iteration, without further nonlinear iterations
  nl_solver->SetRelTol(0.0);
  nl_solver->SetAbsTol(0.0);
  nl_solver->SetMaxIter(1);

  getProblemData().nonlinear_solver = nl_solver;
}

addMFEMPreconditioner()

void MFEMProblem::addMFEMPreconditioner	(	const std::string &	user_object_name,
		const std::string &	name,
		InputParameters &	parameters
	)

Method called in AddMFEMPreconditionerAction which will create the solver.

Definition at line 60 of file MFEMProblem.C.

Referenced by AddMFEMPreconditionerAction::act().

{
  FEProblemBase::addUserObject(user_object_name, name, parameters);
}

addMFEMSolver()

void MFEMProblem::addMFEMSolver	(	const std::string &	user_object_name,
		const std::string &	name,
		InputParameters &	parameters
	)

Method called in AddMFEMSolverAction which will create the solver.

Definition at line 68 of file MFEMProblem.C.

Referenced by AddMFEMSolverAction::act().

{
  FEProblemBase::addUserObject(user_object_name, name, parameters);
  auto object_ptr = getUserObject<MFEMSolverBase>(name).getSharedPtr();

  getProblemData().jacobian_solver = std::dynamic_pointer_cast<MFEMSolverBase>(object_ptr);
}

addMultiApp()

void FEProblemBase::addMultiApp ( const std::string &  multi_app_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Add a MultiApp to the problem.

Definition at line 5476 of file FEProblemBase.C.

{
  parallel_object_only();

  parameters.set<MPI_Comm>("_mpi_comm") = _communicator.get();

  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
    _reinit_displaced_elem = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow MultiApps to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this MultiApp.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }

    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _aux.get();
  }

  std::shared_ptr<MultiApp> multi_app = _factory.create<MultiApp>(multi_app_name, name, parameters);
  logAdd("MultiApp", name, multi_app_name, parameters);
  multi_app->setupPositions();

  _multi_apps.addObject(multi_app);

  // Store TransientMultiApp objects in another container, this is needed for calling computeDT
  std::shared_ptr<TransientMultiApp> trans_multi_app =
      std::dynamic_pointer_cast<TransientMultiApp>(multi_app);
  if (trans_multi_app)
    _transient_multi_apps.addObject(trans_multi_app);
}

addNodalKernel()

void FEProblemBase::addNodalKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 3059 of file FEProblemBase.C.

{
  parallel_object_only();

  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
    _reinit_displaced_elem = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow NodalKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this NodalKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }

    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }
  logAdd("NodalKernel", name, kernel_name, parameters);
  _nl[nl_sys_num]->addNodalKernel(kernel_name, name, parameters);
}

addNotZeroedVectorTag()

void SubProblem::addNotZeroedVectorTag ( const TagID  tag )

inherited

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 150 of file SubProblem.C.

Referenced by FEProblemBase::createTagVectors().

{
  _not_zeroed_tagged_vectors.insert(tag);
}

addObject()

template<typename T >

std::vector< std::shared_ptr< T > > FEProblemBase::addObject ( const std::string &  type, const std::string &  name, InputParameters &  parameters, const bool  threaded = true, const std::string &  var_param_name = "variable"  )

inherited

Method for creating and adding an object to the warehouse.

Template Parameters

T	The base object type (registered in the Factory)

Parameters

type	String type of the object (registered in the Factory)
name	Name for the object to be created
parameters	InputParameters for the object
threaded	Whether or not to create n_threads copies of the object
var_param_name	The name of the parameter on the object which holds the primary variable.

Returns

A vector of shared_ptrs to the added objects

Definition at line 3408 of file FEProblemBase.h.

{
  parallel_object_only();

  logAdd(MooseUtils::prettyCppType<T>(), name, type, parameters);
  // Add the _subproblem and _sys parameters depending on use_displaced_mesh
  addObjectParamsHelper(parameters, name, var_param_name);

  const auto n_threads = threaded ? libMesh::n_threads() : 1;
  std::vector<std::shared_ptr<T>> objects(n_threads);
  for (THREAD_ID tid = 0; tid < n_threads; ++tid)
  {
    std::shared_ptr<T> obj = _factory.create<T>(type, name, parameters, tid);
    theWarehouse().add(obj);
    objects[tid] = std::move(obj);
  }

  return objects;
}

addObjectParamsHelper()

void FEProblemBase::addObjectParamsHelper ( InputParameters &  params, const std::string &  object_name, const std::string &  var_param_name = "variable"  )

protectedinherited

Helper for setting the "_subproblem" and "_sys" parameters in addObject() and in addUserObject().

This is needed due to header includes/forward declaration issues

Definition at line 4410 of file FEProblemBase.C.

Referenced by FEProblemBase::addObject(), and FEProblemBase::addUserObject().

{
  // Due to objects like SolutionUserObject which manipulate libmesh objects
  // and variables directly at the back end, we need a default option here
  // which is going to be the pointer to the first solver system within this
  // problem
  unsigned int sys_num = 0;
  if (parameters.isParamValid(var_param_name))
  {
    const auto variable_name = parameters.varName(var_param_name, object_name);
    if (this->hasVariable(variable_name) || this->hasScalarVariable(variable_name))
      sys_num = getSystem(variable_name).number();
  }
  if (parameters.isParamValid("solver_sys"))
  {
    const auto var_sys_num = sys_num;
    sys_num = getSystemBase(parameters.get<SolverSystemName>("solver_sys")).number();
    if (sys_num != var_sys_num && parameters.isParamValid(var_param_name))
      mooseError("We dont support setting 'variable' to a variable that is not set to the same "
                 "system as the 'solver_sys' parameter");
  }

  if (_displaced_problem && parameters.have_parameter<bool>("use_displaced_mesh") &&
      parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    if (sys_num == _aux->number())
      parameters.set<SystemBase *>("_sys") = &_displaced_problem->systemBaseAuxiliary();
    else
      parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(sys_num);
  }
  else
  {
    // The object requested use_displaced_mesh, but it was overridden
    // due to there being no displacements variables in the [Mesh] block.
    // If that happened, update the value of use_displaced_mesh appropriately.
    if (!_displaced_problem && parameters.have_parameter<bool>("use_displaced_mesh") &&
        parameters.get<bool>("use_displaced_mesh"))
      parameters.set<bool>("use_displaced_mesh") = false;

    parameters.set<SubProblem *>("_subproblem") = this;

    if (sys_num == _aux->number())
      parameters.set<SystemBase *>("_sys") = _aux.get();
    else
      parameters.set<SystemBase *>("_sys") = _solver_systems[sys_num].get();
  }
}

addOutput()

void FEProblemBase::addOutput ( const std::string &  object_type, const std::string &  object_name, InputParameters &  parameters  )

inherited

Adds an Output object.

Definition at line 9066 of file FEProblemBase.C.

{
  parallel_object_only();

  // Get a reference to the OutputWarehouse
  OutputWarehouse & output_warehouse = _app.getOutputWarehouse();

  // Reject the reserved names for objects not built by MOOSE
  if (!parameters.get<bool>("_built_by_moose") && output_warehouse.isReservedName(object_name))
    mooseError("The name '", object_name, "' is a reserved name for output objects");

  // Check that an object by the same name does not already exist; this must be done before the
  // object is created to avoid getting misleading errors from the Parser
  if (output_warehouse.hasOutput(object_name))
    mooseError("An output object named '", object_name, "' already exists");

  // Add a pointer to the FEProblemBase class
  parameters.addPrivateParam<FEProblemBase *>("_fe_problem_base", this);

  // Create common parameter exclude list
  std::vector<std::string> exclude;
  if (object_type == "Console")
  {
    exclude.push_back("execute_on");

    // --show-input should enable the display of the input file on the screen
    if (_app.getParam<bool>("show_input") && parameters.get<bool>("output_screen"))
      parameters.set<ExecFlagEnum>("execute_input_on") = EXEC_INITIAL;
  }
  // Need this because Checkpoint::validParams changes the default value of
  // execute_on
  else if (object_type == "Checkpoint")
    exclude.push_back("execute_on");

  // Apply the common parameters loaded with Outputs input syntax
  const InputParameters * common = output_warehouse.getCommonParameters();
  if (common)
    parameters.applyParameters(*common, exclude);
  if (common && std::find(exclude.begin(), exclude.end(), "execute_on") != exclude.end() &&
      common->isParamSetByUser("execute_on") && object_type != "Console")
    mooseInfoRepeated(
        "'execute_on' parameter specified in [Outputs] block is ignored for object '" +
        object_name +
        "'.\nDefine this object in its own sub-block of [Outputs] to modify its "
        "execution schedule.");

  // Set the correct value for the binary flag for XDA/XDR output
  if (object_type == "XDR")
    parameters.set<bool>("_binary") = true;
  else if (object_type == "XDA")
    parameters.set<bool>("_binary") = false;

  // Adjust the checkpoint suffix if auto recovery was enabled
  if (object_name == "auto_recovery_checkpoint")
    parameters.set<std::string>("suffix") = "auto_recovery";

  // Create the object and add it to the warehouse
  std::shared_ptr<Output> output = _factory.create<Output>(object_type, object_name, parameters);
  logAdd("Output", object_name, object_type, parameters);
  output_warehouse.addOutput(output);
}

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  )

inherited

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 1343 of file SubProblem.h.

Referenced by FunctorMaterial::addFunctorPropertyByBlocks().

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

addPostprocessor()

void MFEMProblem::addPostprocessor ( const std::string &  type, const std::string &  name, InputParameters &  parameters  )

overridevirtual

Override of ExternalProblem::addPostprocessor.

In addition to creating the postprocessor object, it will create a coefficient that will hold its value.

Reimplemented from FEProblemBase.

Definition at line 366 of file MFEMProblem.C.

{
  ExternalProblem::addPostprocessor(type, name, parameters);
  const PostprocessorValue & val = getPostprocessorValueByName(name);
  getCoefficients().declareScalar<mfem::FunctionCoefficient>(
      name, [&val](const mfem::Vector &) -> mfem::real_t { return val; });
}

addPredictor()

void FEProblemBase::addPredictor ( const std::string &  type, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 7034 of file FEProblemBase.C.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector().

{
  parallel_object_only();

  if (!numNonlinearSystems() && numLinearSystems())
    mooseError("Vector bounds cannot be used with LinearSystems!");

  parameters.set<SubProblem *>("_subproblem") = this;
  std::shared_ptr<Predictor> predictor = _factory.create<Predictor>(type, name, parameters);
  logAdd("Predictor", name, type, parameters);

  for (auto & nl : _nl)
    nl->setPredictor(predictor);
}

addReporter()

void FEProblemBase::addReporter ( const std::string &  type, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Add a Reporter object to the simulation.

Parameters

type	C++ object type to construct
name	A uniquely identifying object name
parameters	Complete parameters for the object to be created.

For an example use, refer to AddReporterAction.C/h

Definition at line 4490 of file FEProblemBase.C.

Referenced by MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer().

{
  // Check for name collision
  if (hasUserObject(name))
    mooseError("A ",
               getUserObjectBase(name).typeAndName(),
               " already exists. You may not add a Reporter by the same name.");

  addUserObject(type, name, parameters);
}

addResidual()

void FEProblemBase::addResidual ( const THREAD_ID  tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1876 of file FEProblemBase.C.

Referenced by ComputeDiracThread::postElement().

{
  _assembly[tid][_current_nl_sys->number()]->addResidual(Assembly::GlobalDataKey{},
                                                         currentResidualVectorTags());

  if (_displaced_problem)
    _displaced_problem->addResidual(tid);
}

addResidualLower()

void FEProblemBase::addResidualLower ( const THREAD_ID  tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1896 of file FEProblemBase.C.

Referenced by ComputeResidualThread::accumulateLower(), ComputeResidualAndJacobianThread::accumulateLower(), ComputeResidualThread::accumulateNeighborLower(), and ComputeResidualAndJacobianThread::accumulateNeighborLower().

{
  _assembly[tid][_current_nl_sys->number()]->addResidualLower(Assembly::GlobalDataKey{},
                                                              currentResidualVectorTags());

  if (_displaced_problem)
    _displaced_problem->addResidualLower(tid);
}

addResidualNeighbor()

void FEProblemBase::addResidualNeighbor ( const THREAD_ID  tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1886 of file FEProblemBase.C.

Referenced by ComputeResidualThread::accumulateNeighbor(), ComputeResidualAndJacobianThread::accumulateNeighbor(), ComputeResidualThread::accumulateNeighborLower(), and ComputeResidualAndJacobianThread::accumulateNeighborLower().

{
  _assembly[tid][_current_nl_sys->number()]->addResidualNeighbor(Assembly::GlobalDataKey{},
                                                                 currentResidualVectorTags());

  if (_displaced_problem)
    _displaced_problem->addResidualNeighbor(tid);
}

addResidualScalar()

void FEProblemBase::addResidualScalar ( const THREAD_ID  tid = 0 )

virtualinherited

Definition at line 1906 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeResidualInternal().

{
  _assembly[tid][_current_nl_sys->number()]->addResidualScalar(Assembly::GlobalDataKey{},
                                                               currentResidualVectorTags());
}

addSampler()

void FEProblemBase::addSampler ( const std::string &  type, const std::string &  name, InputParameters &  parameters  )

virtualinherited

The following functions will enable MOOSE to have the capability to import Samplers.

Definition at line 2757 of file FEProblemBase.C.

{
  const auto samplers = addObject<Sampler>(type, name, parameters);
  for (auto & sampler : samplers)
    sampler->init();
}

addScalarKernel()

void FEProblemBase::addScalarKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 3092 of file FEProblemBase.C.

{
  parallel_object_only();

  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a ScalarKernel to a linear variable/system, which is not "
               "supported at the moment!");

  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow ScalarKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this ScalarKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }

    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }

  logAdd("ScalarKernel", name, kernel_name, parameters);
  _nl[nl_sys_num]->addScalarKernel(kernel_name, name, parameters);
}

addSubMesh()

void MFEMProblem::addSubMesh	(	const std::string &	user_object_name,
		const std::string &	name,
		InputParameters &	parameters
	)

Add an MFEM SubMesh to the problem.

Definition at line 480 of file MFEMProblem.C.

Referenced by AddMFEMSubMeshAction::act().

{
  // Add MFEM SubMesh.
  FEProblemBase::addUserObject(var_type, var_name, parameters);
  // Register submesh.
  MFEMSubMesh & mfem_submesh = getUserObject<MFEMSubMesh>(var_name);
  getProblemData().submeshes.Register(var_name, mfem_submesh.getSubMesh());
}

addTimeIntegrator()

void FEProblemBase::addTimeIntegrator ( const std::string &  type, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 6999 of file FEProblemBase.C.

Referenced by TransientBase::setupTimeIntegrator().

{
  parallel_object_only();

  parameters.set<SubProblem *>("_subproblem") = this;
  logAdd("TimeIntegrator", name, type, parameters);
  _aux->addTimeIntegrator(type, name + ":aux", parameters);
  for (auto & sys : _solver_systems)
    sys->addTimeIntegrator(type, name + ":" + sys->name(), parameters);
  _has_time_integrator = true;

  // add vectors to store u_dot, u_dotdot, udot_old, u_dotdot_old and
  // solution vectors older than 2 time steps, if requested by the time
  // integrator
  _aux->addDotVectors();
  for (auto & nl : _nl)
  {
    nl->addDotVectors();

    auto tag_udot = nl->getTimeIntegrators()[0]->uDotFactorTag();
    if (!nl->hasVector(tag_udot))
      nl->associateVectorToTag(*nl->solutionUDot(), tag_udot);
    auto tag_udotdot = nl->getTimeIntegrators()[0]->uDotDotFactorTag();
    if (!nl->hasVector(tag_udotdot) && uDotDotRequested())
      nl->associateVectorToTag(*nl->solutionUDotDot(), tag_udotdot);
  }

  if (_displaced_problem)
    // Time integrator does not exist when displaced problem is created.
    _displaced_problem->addTimeIntegrator();
}

addTransfer()

void MFEMProblem::addTransfer ( const std::string &  transfer_name, const std::string &  name, InputParameters &  parameters  )

overridevirtual

Add transfers between MultiApps and/or MFEM SubMeshes.

Reimplemented from FEProblemBase.

Definition at line 492 of file MFEMProblem.C.

{
  if (parameters.getBase() == "MFEMSubMeshTransfer")
    FEProblemBase::addUserObject(transfer_name, name, parameters);
  else
    FEProblemBase::addTransfer(transfer_name, name, parameters);
}

addUserObject()

std::vector< std::shared_ptr< UserObject > > FEProblemBase::addUserObject ( const std::string &  user_object_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 4504 of file FEProblemBase.C.

Referenced by addAuxKernel(), addBoundaryCondition(), addFESpace(), addFunctorMaterial(), addGridFunction(), addInitialCondition(), addKernel(), addMFEMPreconditioner(), addMFEMSolver(), FEProblemBase::addPostprocessor(), FEProblemBase::addReporter(), addSubMesh(), addTransfer(), and FEProblemBase::addVectorPostprocessor().

{
  parallel_object_only();

  std::vector<std::shared_ptr<UserObject>> uos;

  // Add the _subproblem and _sys parameters depending on use_displaced_mesh
  addObjectParamsHelper(parameters, name);

  for (const auto tid : make_range(libMesh::n_threads()))
  {
    // Create the UserObject
    std::shared_ptr<UserObject> user_object =
        _factory.create<UserObject>(user_object_name, name, parameters, tid);
    logAdd("UserObject", name, user_object_name, parameters);
    uos.push_back(user_object);

    if (tid != 0)
      user_object->setPrimaryThreadCopy(uos[0].get());

    // TODO: delete this line after apps have been updated to not call getUserObjects
    _all_user_objects.addObject(user_object, tid);

    theWarehouse().add(user_object);

    // Attempt to create all the possible UserObject types
    auto euo = std::dynamic_pointer_cast<ElementUserObject>(user_object);
    auto suo = std::dynamic_pointer_cast<SideUserObject>(user_object);
    auto isuo = std::dynamic_pointer_cast<InternalSideUserObject>(user_object);
    auto iuo = std::dynamic_pointer_cast<InterfaceUserObjectBase>(user_object);
    auto nuo = std::dynamic_pointer_cast<NodalUserObject>(user_object);
    auto duo = std::dynamic_pointer_cast<DomainUserObject>(user_object);
    auto guo = std::dynamic_pointer_cast<GeneralUserObject>(user_object);
    auto tguo = std::dynamic_pointer_cast<ThreadedGeneralUserObject>(user_object);
    auto muo = std::dynamic_pointer_cast<MortarUserObject>(user_object);

    // Account for displaced mesh use
    if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
    {
      // Whether to re-init or not depends on the attributes of the base classes.
      // For example, InterfaceUOBase has "_current_side_elem" and "_neighbor_elem"
      // so it needs to reinit on displaced neighbors and faces
      // _reinit_displaced_elem -> _current_elem will be reinited
      // _reinit_displaced_face -> _current_elem, lowerD if any and _current_side_elem to be
      // reinited _reinit_displaced_neighbor -> _current_elem, lowerD if any and _current_neighbor
      // to be reinited Note that as soon as you use materials on the displaced mesh, all three get
      // turned on.
      if (euo || nuo || duo)
        _reinit_displaced_elem = true;
      if (suo || duo || isuo || iuo)
        _reinit_displaced_face = true;
      if (iuo || duo || isuo)
        _reinit_displaced_neighbor = true;
    }

    // These objects only require one thread
    if ((guo && !tguo) || muo)
      break;
  }

  // Add as a Functor if it is one. We usually need to add the user object from thread 0 as the
  // registered functor for all threads because when user objects are thread joined, generally only
  // the primary thread copy ends up with all the data
  for (const auto tid : make_range(libMesh::n_threads()))
  {
    const decltype(uos)::size_type uo_index = uos.front()->needThreadedCopy() ? tid : 0;
    if (const auto functor = dynamic_cast<Moose::FunctorBase<Real> *>(uos[uo_index].get()))
    {
      this->addFunctor(name, *functor, tid);
      if (_displaced_problem)
        _displaced_problem->addFunctor(name, *functor, tid);
    }
  }

  return uos;
}

addVariable()

void MFEMProblem::addVariable ( const std::string &  var_type, const std::string &  var_name, InputParameters &  parameters  )

overridevirtual

Override of ExternalProblem::addVariable.

Sets a MFEM grid function (and time derivative, for transient problems) to be used in the MFEM solve.

Reimplemented from FEProblemBase.

Definition at line 162 of file MFEMProblem.C.

{
  addGridFunction(var_type, var_name, parameters);
  // MOOSE variables store DoFs for the trial variable and its time derivatives up to second order;
  // MFEM GridFunctions store data for only one set of DoFs each, so we must add additional
  // GridFunctions for time derivatives.
  if (isTransient())
    addGridFunction(var_type, Moose::MFEM::GetTimeDerivativeName(var_name), parameters);
}

addVectorPostprocessor()

void FEProblemBase::addVectorPostprocessor ( const std::string &  pp_name, const std::string &  name, InputParameters &  parameters  )

virtualinherited

Definition at line 4476 of file FEProblemBase.C.

Referenced by ExtraIDIntegralReporter::ExtraIDIntegralReporter().

{
  // Check for name collision
  if (hasUserObject(name))
    mooseError("A ",
               getUserObjectBase(name).typeAndName(),
               " already exists. You may not add a VectorPostprocessor by the same name.");

  addUserObject(pp_name, name, parameters);
}

addVectorTag()

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

virtualinherited

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 93 of file SubProblem.C.

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

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

advanceMultiApps()

void FEProblemBase::advanceMultiApps ( ExecFlagType  type )

inlineinherited

Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep depending on your purpose.

Definition at line 1481 of file FEProblemBase.h.

  {
    mooseDeprecated("Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep "
                    "depending on your purpose");
    finishMultiAppStep(type);
  }

advanceState()

void FEProblemBase::advanceState ( )

virtualinherited

Advance all of the state holding vectors / datastructures so that we can move to the next timestep.

Reimplemented in DumpObjectsProblem.

Definition at line 6838 of file FEProblemBase.C.

Referenced by MFEMSteady::execute(), SteadyBase::execute(), Eigenvalue::execute(), TransientBase::incrementStepOrReject(), NonlinearEigen::init(), TransientMultiApp::setupApp(), ExplicitTVDRK2::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), NonlinearEigen::takeStep(), and InversePowerMethod::takeStep().

{
  TIME_SECTION("advanceState", 5, "Advancing State");

  for (auto & sys : _solver_systems)
    sys->copyOldSolutions();
  _aux->copyOldSolutions();

  if (_displaced_problem)
  {
    for (const auto i : index_range(_solver_systems))
      _displaced_problem->solverSys(i).copyOldSolutions();
    _displaced_problem->auxSys().copyOldSolutions();
  }

  _reporter_data.copyValuesBack();

  getMooseApp().getChainControlDataSystem().copyValuesBack();

  if (_material_props.hasStatefulProperties())
    _material_props.shift();

  if (_bnd_material_props.hasStatefulProperties())
    _bnd_material_props.shift();

  if (_neighbor_material_props.hasStatefulProperties())
    _neighbor_material_props.shift();

#ifdef MOOSE_KOKKOS_ENABLED
  if (_kokkos_material_props.hasStatefulProperties())
    _kokkos_material_props.shift();

  if (_kokkos_bnd_material_props.hasStatefulProperties())
    _kokkos_bnd_material_props.shift();

  if (_kokkos_neighbor_material_props.hasStatefulProperties())
    _kokkos_neighbor_material_props.shift();
#endif
}

allowInvalidSolution()

bool FEProblemBase::allowInvalidSolution ( ) const

inlineinherited

Whether to accept / allow an invalid solution.

Definition at line 2191 of file FEProblemBase.h.

Referenced by FEProblemBase::acceptInvalidSolution().

{ return _allow_invalid_solution; }

allowOutput() [1/2]

void FEProblemBase::allowOutput ( bool  state )

inherited

Ability to enable/disable all output calls.

This is needed by Multiapps and applications to disable output for cases when executioners call other executions and when Multiapps are sub cycling.

Definition at line 6945 of file FEProblemBase.C.

Referenced by TransientMultiApp::resetApp(), and TransientMultiApp::solveStep().

{
  _app.getOutputWarehouse().allowOutput(state);
}

allowOutput() [2/2]

template<typename T >

void FEProblemBase::allowOutput ( bool  state )

inherited

Definition at line 3359 of file FEProblemBase.h.

{
  _app.getOutputWarehouse().allowOutput<T>(state);
}

areCoupled()

bool FEProblemBase::areCoupled ( const unsigned int  ivar, const unsigned int  jvar, const unsigned int  nl_sys_num  ) const

inherited

Definition at line 6378 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintJacobians().

{
  return (*_cm[nl_sys])(ivar, jvar);
}

assembly() [1/2]

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

inlineoverridevirtualinherited

Implements SubProblem.

Definition at line 3507 of file FEProblemBase.h.

Referenced by ArrayNodalBC::computeJacobian(), VectorNodalBC::computeJacobian(), NodalBC::computeJacobian(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), VectorNodalBC::computeOffDiagJacobian(), ArrayNodalBC::computeOffDiagJacobian(), NodalBC::computeOffDiagJacobian(), NonlinearSystemBase::constraintJacobians(), FEProblemBase::initialSetup(), ComputeBoundaryInitialConditionThread::onNode(), MaxQpsThread::operator()(), and FEProblemBase::reinitScalars().

{
  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
  mooseAssert(sys_num < _assembly[tid].size(),
              "System number larger than the assembly container size");
  return *_assembly[tid][sys_num];
}

assembly() [2/2]

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

inlineoverridevirtualinherited

Implements SubProblem.

Definition at line 3516 of file FEProblemBase.h.

{
  mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
  mooseAssert(sys_num < _assembly[tid].size(),
              "System number larger than the assembly container size");
  return *_assembly[tid][sys_num];
}

automaticScaling() [1/4]

bool SubProblem::automaticScaling ( ) const

inherited

Automatic scaling getter.

Returns

A boolean representing whether we are performing automatic scaling

Definition at line 1163 of file SubProblem.C.

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

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

automaticScaling() [2/4]

void SubProblem::automaticScaling

inherited

Automatic scaling setter.

Parameters

automatic_scaling

A boolean representing whether we are performing automatic scaling

Definition at line 1156 of file SubProblem.C.

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

automaticScaling() [3/4]

bool SubProblem::automaticScaling

inherited

Automatic scaling getter.

Returns

A boolean representing whether we are performing automatic scaling

Definition at line 1163 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();
}

automaticScaling() [4/4]

void FEProblemBase::automaticScaling ( bool  automatic_scaling )

overridevirtualinherited

Automatic scaling setter.

Parameters

automatic_scaling

A boolean representing whether we are performing automatic scaling

Reimplemented from SubProblem.

Definition at line 9261 of file FEProblemBase.C.

Referenced by DisplacedProblem::DisplacedProblem(), and FEProblemSolve::FEProblemSolve().

{
  if (_displaced_problem)
    _displaced_problem->automaticScaling(automatic_scaling);

  SubProblem::automaticScaling(automatic_scaling);
}

backupMultiApps()

void FEProblemBase::backupMultiApps ( ExecFlagType  type )

inherited

Backup the MultiApps associated with the ExecFlagType.

Definition at line 5743 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup(), MFEMProblemSolve::solve(), and FixedPointSolve::solve().

{
  const auto & multi_apps = _multi_apps[type].getActiveObjects();

  if (multi_apps.size())
  {
    TIME_SECTION("backupMultiApps", 5, "Backing Up MultiApp");

    if (_verbose_multiapps)
      _console << COLOR_CYAN << "\nBacking Up MultiApps on " << type.name() << COLOR_DEFAULT
               << std::endl;

    for (const auto & multi_app : multi_apps)
      multi_app->backup();

    MooseUtils::parallelBarrierNotify(_communicator, _parallel_barrier_messaging);

    if (_verbose_multiapps)
      _console << COLOR_CYAN << "Finished Backing Up MultiApps on " << type.name() << "\n"
               << COLOR_DEFAULT << std::endl;
  }
}

bumpAllQRuleOrder()

void FEProblemBase::bumpAllQRuleOrder ( libMesh::Order  order, SubdomainID  block  )

inherited

Definition at line 6235 of file FEProblemBase.C.

{
  for (unsigned int tid = 0; tid < libMesh::n_threads(); ++tid)
    for (const auto i : index_range(_nl))
      _assembly[tid][i]->bumpAllQRuleOrder(order, block);

  if (_displaced_problem)
    _displaced_problem->bumpAllQRuleOrder(order, block);

  updateMaxQps();
}

bumpVolumeQRuleOrder()

void FEProblemBase::bumpVolumeQRuleOrder ( libMesh::Order  order, SubdomainID  block  )

inherited

Increases the element/volume quadrature order for the specified mesh block if and only if the current volume quadrature order is lower.

This can only cause the quadrature level to increase. If volume_order is lower than or equal to the current volume/elem quadrature rule order, then nothing is done (i.e. this function is idempotent).

Definition at line 6222 of file FEProblemBase.C.

{
  for (unsigned int tid = 0; tid < libMesh::n_threads(); ++tid)
    for (const auto i : index_range(_nl))
      _assembly[tid][i]->bumpVolumeQRuleOrder(order, block);

  if (_displaced_problem)
    _displaced_problem->bumpVolumeQRuleOrder(order, block);

  updateMaxQps();
}

cacheJacobian()

void FEProblemBase::cacheJacobian ( const THREAD_ID  tid )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2027 of file FEProblemBase.C.

Referenced by ComputeResidualAndJacobianThread::accumulate(), NonlinearSystemBase::constraintJacobians(), and ComputeJacobianThread::postElement().

{
  SubProblem::cacheJacobian(tid);
  if (_displaced_problem)
    _displaced_problem->cacheJacobian(tid);
}

cacheJacobianNeighbor()

void FEProblemBase::cacheJacobianNeighbor ( const THREAD_ID  tid )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2035 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintJacobians().

{
  SubProblem::cacheJacobianNeighbor(tid);
  if (_displaced_problem)
    _displaced_problem->cacheJacobianNeighbor(tid);
}

cacheResidual()

void FEProblemBase::cacheResidual ( const THREAD_ID  tid )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 1913 of file FEProblemBase.C.

Referenced by ComputeResidualThread::accumulate(), ComputeResidualAndJacobianThread::accumulate(), and NonlinearSystemBase::constraintResiduals().

{
  SubProblem::cacheResidual(tid);
  if (_displaced_problem)
    _displaced_problem->cacheResidual(tid);
}

cacheResidualNeighbor()

void FEProblemBase::cacheResidualNeighbor ( const THREAD_ID  tid )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 1921 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintResiduals().

{
  SubProblem::cacheResidualNeighbor(tid);
  if (_displaced_problem)
    _displaced_problem->cacheResidualNeighbor(tid);
}

callMooseError() [1/2]

void MooseBase::callMooseError ( std::string  msg, const bool  with_prefix, const hit::Node *  node = nullptr  ) 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

Definition at line 105 of file MooseBase.C.

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

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

callMooseError() [2/2]

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

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

Definition at line 113 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);
}

checkBlockMatProps()

void SubProblem::checkBlockMatProps ( )

virtualinherited

Checks block material properties integrity.

See also

FEProblemBase::checkProblemIntegrity

Definition at line 624 of file SubProblem.C.

Referenced by FEProblemBase::checkProblemIntegrity().

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

checkBoundaryMatProps()

void SubProblem::checkBoundaryMatProps ( )

virtualinherited

Checks boundary material properties integrity.

See also

FEProblemBase::checkProblemIntegrity

Definition at line 666 of file SubProblem.C.

Referenced by FEProblemBase::checkProblemIntegrity().

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

checkCoordinateSystems()

void FEProblemBase::checkCoordinateSystems ( )

protectedinherited

Verify that there are no element type/coordinate type conflicts.

Definition at line 8870 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

{
  _mesh.checkCoordinateSystems();
}

checkDependMaterialsHelper()

void FEProblemBase::checkDependMaterialsHelper ( const std::map< SubdomainID, std::vector< std::shared_ptr< MaterialBase >>> &  materials_map )

protectedinherited

Helper method for checking Material object dependency.

See also

checkProblemIntegrity

These two sets are used to make sure that all dependent props on a block are actually supplied

Definition at line 8749 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

{
  for (const auto & it : materials_map)
  {
    std::set<std::string> block_depend_props, block_supplied_props;

    for (const auto & mat1 : it.second)
    {
      auto & alldeps = mat1->getMatPropDependencies(); // includes requested stateful props
      for (auto & dep : alldeps)
        block_depend_props.insert(_material_prop_registry.getName(dep));

      // See if any of the active materials supply this property
      for (const auto & mat2 : it.second)
      {
        const std::set<std::string> & supplied_props = mat2->MaterialBase::getSuppliedItems();
        block_supplied_props.insert(supplied_props.begin(), supplied_props.end());
      }
    }

    // Add zero material properties specific to this block and unrestricted
    block_supplied_props.insert(_zero_block_material_props[it.first].begin(),
                                _zero_block_material_props[it.first].end());

    // Error check to make sure all properties consumed by materials are supplied on this block
    std::set<std::string> difference;
    std::set_difference(block_depend_props.begin(),
                        block_depend_props.end(),
                        block_supplied_props.begin(),
                        block_supplied_props.end(),
                        std::inserter(difference, difference.end()));

    if (!difference.empty())
    {
      std::ostringstream oss;
      oss << "One or more Material Properties were not supplied on block ";
      const std::string & subdomain_name = _mesh.getSubdomainName(it.first);
      if (subdomain_name.length() > 0)
        oss << subdomain_name << " (" << it.first << ")";
      else
        oss << it.first;
      oss << ":\n";
      for (const auto & name : difference)
        oss << name << "\n";
      mooseError(oss.str());
    }
  }

  // This loop checks that materials are not supplied by multiple Material objects
  for (const auto & it : materials_map)
  {
    const auto & materials = it.second;
    std::set<std::string> inner_supplied, outer_supplied;

    for (const auto & outer_mat : materials)
    {
      // Storage for properties for this material (outer) and all other materials (inner)
      outer_supplied = outer_mat->getSuppliedItems();
      inner_supplied.clear();

      // Property to material map for error reporting
      std::map<std::string, std::set<std::string>> prop_to_mat;
      for (const auto & name : outer_supplied)
        prop_to_mat[name].insert(outer_mat->name());

      for (const auto & inner_mat : materials)
      {
        if (outer_mat == inner_mat)
          continue;

        // Check whether these materials are an AD pair
        auto outer_mat_type = outer_mat->type();
        auto inner_mat_type = inner_mat->type();
        removeSubstring(outer_mat_type, "<RESIDUAL>");
        removeSubstring(outer_mat_type, "<JACOBIAN>");
        removeSubstring(inner_mat_type, "<RESIDUAL>");
        removeSubstring(inner_mat_type, "<JACOBIAN>");
        if (outer_mat_type == inner_mat_type && outer_mat_type != outer_mat->type() &&
            inner_mat_type != inner_mat->type())
          continue;

        inner_supplied.insert(inner_mat->getSuppliedItems().begin(),
                              inner_mat->getSuppliedItems().end());

        for (const auto & inner_supplied_name : inner_supplied)
          prop_to_mat[inner_supplied_name].insert(inner_mat->name());
      }

      // Test that a property isn't supplied on multiple blocks
      std::set<std::string> intersection;
      std::set_intersection(outer_supplied.begin(),
                            outer_supplied.end(),
                            inner_supplied.begin(),
                            inner_supplied.end(),
                            std::inserter(intersection, intersection.end()));

      if (!intersection.empty())
      {
        std::ostringstream oss;
        oss << "The following material properties are declared on block " << it.first
            << " by multiple materials:\n";
        oss << ConsoleUtils::indent(2) << std::setw(30) << std::left << "Material Property"
            << "Material Objects\n";
        for (const auto & outer_name : intersection)
        {
          oss << ConsoleUtils::indent(2) << std::setw(30) << std::left << outer_name;
          for (const auto & inner_name : prop_to_mat[outer_name])
            oss << inner_name << " ";
          oss << '\n';
        }

        mooseError(oss.str());
        break;
      }
    }
  }
}

checkDisplacementOrders()

void FEProblemBase::checkDisplacementOrders ( )

protectedinherited

Verify that SECOND order mesh uses SECOND order displacements.

Definition at line 8673 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

{
  if (_displaced_problem)
  {
    bool mesh_has_second_order_elements = false;
    for (const auto & elem : as_range(_displaced_mesh->activeLocalElementsBegin(),
                                      _displaced_mesh->activeLocalElementsEnd()))
    {
      if (elem->default_order() == SECOND)
      {
        mesh_has_second_order_elements = true;
        break;
      }
    }

    // We checked our local elements, so take the max over all processors.
    _displaced_mesh->comm().max(mesh_has_second_order_elements);

    // If the Mesh has second order elements, make sure the
    // displacement variables are second-order.
    if (mesh_has_second_order_elements)
    {
      const std::vector<std::string> & displacement_variables =
          _displaced_problem->getDisplacementVarNames();

      for (const auto & var_name : displacement_variables)
      {
        MooseVariableFEBase & mv =
            _displaced_problem->getVariable(/*tid=*/0,
                                            var_name,
                                            Moose::VarKindType::VAR_ANY,
                                            Moose::VarFieldType::VAR_FIELD_STANDARD);
        if (mv.order() != SECOND)
          mooseError("Error: mesh has SECOND order elements, so all displacement variables must be "
                     "SECOND order.");
      }
    }
  }
}

checkDuplicatePostprocessorVariableNames()

void FEProblemBase::checkDuplicatePostprocessorVariableNames ( )

inherited

Definition at line 1528 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

{
  for (const auto & pp : _reporter_data.getPostprocessorNames())
    if (hasScalarVariable(pp))
      mooseError("Postprocessor \"" + pp +
                 "\" has the same name as a scalar variable in the system.");
}

checkExceptionAndStopSolve()

void FEProblemBase::checkExceptionAndStopSolve ( bool  print_message = true )

virtualinherited

Check to see if an exception has occurred on any processor and, if possible, force the solve to fail, which will result in the time step being cut.

Notes:

• The exception have be registered by calling setException() prior to calling this.
• This is collective on MPI, and must be called simultaneously by all processors!
• If called when the solve can be interruped, it will do so and also throw a MooseException, which must be handled.
• If called at a stage in the execution when the solve cannot be interupted (i.e., there is no solve active), it will generate an error and terminate the application.
• DO NOT CALL THIS IN A THREADED REGION! This is meant to be called just after a threaded section.

Parameters

print_message

whether to print a message with exception information

Definition at line 6666 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeJacobianInternal(), FEProblemBase::handleException(), and DisplacedProblem::updateMesh().

{
  if (_skip_exception_check)
    return;

  TIME_SECTION("checkExceptionAndStopSolve", 5);

  // See if any processor had an exception.  If it did, get back the
  // processor that the exception occurred on.
  unsigned int processor_id;

  _communicator.maxloc(_has_exception, processor_id);

  if (_has_exception)
  {
    _communicator.broadcast(_exception_message, processor_id);

    if (_current_execute_on_flag == EXEC_LINEAR || _current_execute_on_flag == EXEC_NONLINEAR ||
        _current_execute_on_flag == EXEC_POSTCHECK)
    {
      // Print the message
      if (_communicator.rank() == 0 && print_message)
      {
        _console << "\n" << _exception_message << "\n";
        if (isTransient())
          _console
              << "To recover, the solution will fail and then be re-attempted with a reduced time "
                 "step.\n"
              << std::endl;
      }

      // Stop the solve -- this entails setting
      // SNESSetFunctionDomainError() or directly inserting NaNs in the
      // residual vector to let PETSc >= 3.6 return DIVERGED_NANORINF.
      if (_current_nl_sys)
        _current_nl_sys->stopSolve(_current_execute_on_flag, _fe_vector_tags);

      if (_current_linear_sys)
        _current_linear_sys->stopSolve(_current_execute_on_flag, _fe_vector_tags);

      // and close Aux system (we MUST do this here; see #11525)
      _aux->solution().close();

      // We've handled this exception, so we no longer have one.
      _has_exception = false;

      // Force the next non-linear convergence check to fail (and all further residual evaluation
      // to be skipped).
      _fail_next_system_convergence_check = true;

      // Repropagate the exception, so it can be caught at a higher level, typically
      // this is NonlinearSystem::computeResidual().
      throw MooseException(_exception_message);
    }
    else
      mooseError("The following parallel-communicated exception was detected during " +
                 Moose::stringify(_current_execute_on_flag) + " evaluation:\n" +
                 _exception_message +
                 "\nBecause this did not occur during residual evaluation, there"
                 " is no way to handle this, so the solution is aborting.\n");
  }
}

checkingUOAuxState()

bool FEProblemBase::checkingUOAuxState ( ) const

inlineinherited

Return a flag to indicate whether we are executing user objects and auxliary kernels for state check Note: This function can return true only when hasUOAuxStateCheck() returns true, i.e.

the check has been activated by users through Problem/check_uo_aux_state input parameter.

Definition at line 209 of file FEProblemBase.h.

Referenced by MemoryUsage::execute(), VectorMemoryUsage::execute(), PerfGraphData::finalize(), MemoryUsage::finalize(), and VectorMemoryUsage::finalize().

{ return _checking_uo_aux_state; }

checkNonlocalCoupling()

void FEProblemBase::checkNonlocalCoupling ( )

inherited

Returns

Flag indicating nonlocal coupling exists or not.

Definition at line 1653 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

{
  TIME_SECTION("checkNonlocalCoupling", 5, "Checking Nonlocal Coupling");

  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
    for (auto & nl : _nl)
    {
      const auto & all_kernels = nl->getKernelWarehouse();
      const auto & kernels = all_kernels.getObjects(tid);
      for (const auto & kernel : kernels)
      {
        std::shared_ptr<NonlocalKernel> nonlocal_kernel =
            std::dynamic_pointer_cast<NonlocalKernel>(kernel);
        if (nonlocal_kernel)
        {
          if (_calculate_jacobian_in_uo)
            _requires_nonlocal_coupling = true;
          _nonlocal_kernels.addObject(kernel, tid);
        }
      }
      const MooseObjectWarehouse<IntegratedBCBase> & all_integrated_bcs =
          nl->getIntegratedBCWarehouse();
      const auto & integrated_bcs = all_integrated_bcs.getObjects(tid);
      for (const auto & integrated_bc : integrated_bcs)
      {
        std::shared_ptr<NonlocalIntegratedBC> nonlocal_integrated_bc =
            std::dynamic_pointer_cast<NonlocalIntegratedBC>(integrated_bc);
        if (nonlocal_integrated_bc)
        {
          if (_calculate_jacobian_in_uo)
            _requires_nonlocal_coupling = true;
          _nonlocal_integrated_bcs.addObject(integrated_bc, tid);
        }
      }
    }
}

checkNonlocalCouplingRequirement()

bool FEProblemBase::checkNonlocalCouplingRequirement ( ) const

overridevirtualinherited

Returns

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

Implements SubProblem.

Definition at line 9691 of file FEProblemBase.C.

Referenced by DisplacedProblem::checkNonlocalCouplingRequirement(), ComputeJacobianThread::compute(), ComputeFullJacobianThread::computeOnBoundary(), and ComputeFullJacobianThread::computeOnElement().

{
  return _requires_nonlocal_coupling;
}

checkProblemIntegrity()

void FEProblemBase::checkProblemIntegrity ( )

virtualinherited

Method called to perform a series of sanity checks before a simulation is run.

This method doesn't return when errors are found, instead it generally calls mooseError() directly.

If a material is specified for any block in the simulation, then all blocks must have a material specified.

unsigned int is necessary to print SubdomainIDs in the statement below

vector is necessary to get the subdomain names

Reimplemented in EigenProblem.

Definition at line 8501 of file FEProblemBase.C.

Referenced by EigenProblem::checkProblemIntegrity().

{
  TIME_SECTION("checkProblemIntegrity", 5);

  // Subdomains specified by the "Problem/block" parameter
  const auto & subdomain_names = getParam<std::vector<SubdomainName>>("block");
  auto mesh_subdomains_vec = MooseMeshUtils::getSubdomainIDs(_mesh, subdomain_names);
  std::set<SubdomainID> mesh_subdomains(mesh_subdomains_vec.begin(), mesh_subdomains_vec.end());

  // Check kernel coverage of subdomains (blocks) in the mesh
  if (!_skip_nl_system_check && _solve && _kernel_coverage_check != CoverageCheckMode::FALSE &&
      _kernel_coverage_check != CoverageCheckMode::OFF)
  {
    std::set<SubdomainID> blocks;
    if (_kernel_coverage_check == CoverageCheckMode::TRUE ||
        _kernel_coverage_check == CoverageCheckMode::ON)
      blocks = mesh_subdomains;
    else if (_kernel_coverage_check == CoverageCheckMode::SKIP_LIST)
    {
      blocks = mesh_subdomains;
      for (const auto & subdomain_name : _kernel_coverage_blocks)
      {
        const auto id = _mesh.getSubdomainID(subdomain_name);
        if (id == Moose::INVALID_BLOCK_ID)
          paramError("kernel_coverage_block_list",
                     "Subdomain \"",
                     subdomain_name,
                     "\" not found in mesh.");
        blocks.erase(id);
      }
    }
    else if (_kernel_coverage_check == CoverageCheckMode::ONLY_LIST)
      for (const auto & subdomain_name : _kernel_coverage_blocks)
      {
        const auto id = _mesh.getSubdomainID(subdomain_name);
        if (id == Moose::INVALID_BLOCK_ID)
          paramError("kernel_coverage_block_list",
                     "Subdomain \"",
                     subdomain_name,
                     "\" not found in mesh.");
        blocks.insert(id);
      }
    if (!blocks.empty())
      for (auto & nl : _nl)
        nl->checkKernelCoverage(blocks);
  }

  // Check materials
  {
#ifdef LIBMESH_ENABLE_AMR
    if ((_adaptivity.isOn() || _num_grid_steps) &&
        (_material_props.hasStatefulProperties() || _bnd_material_props.hasStatefulProperties() ||
         _neighbor_material_props.hasStatefulProperties()))
    {
      _console << "Using EXPERIMENTAL Stateful Material Property projection with Adaptivity!\n"
               << std::flush;
    }
#endif

    std::set<SubdomainID> local_mesh_subs(mesh_subdomains);

    if (_material_coverage_check != CoverageCheckMode::FALSE &&
        _material_coverage_check != CoverageCheckMode::OFF)
    {
      bool check_material_coverage = false;
      std::set<SubdomainID> ids = _all_materials.getActiveBlocks();
      for (const auto & id : ids)
      {
        local_mesh_subs.erase(id);
        check_material_coverage = true;
      }

      // did the user limit the subdomains to be checked?
      if (_material_coverage_check == CoverageCheckMode::SKIP_LIST)
      {
        for (const auto & subdomain_name : _material_coverage_blocks)
        {
          const auto id = _mesh.getSubdomainID(subdomain_name);
          if (id == Moose::INVALID_BLOCK_ID)
            paramError("material_coverage_block_list",
                       "Subdomain \"" + subdomain_name + "\" not found in mesh.");
          local_mesh_subs.erase(id);
        }
      }
      else if (_material_coverage_check == CoverageCheckMode::ONLY_LIST)
      {
        std::set<SubdomainID> blocks(local_mesh_subs);
        for (const auto & subdomain_name : _material_coverage_blocks)
        {
          const auto id = _mesh.getSubdomainID(subdomain_name);
          if (id == Moose::INVALID_BLOCK_ID)
            paramError("material_coverage_block_list",
                       "Subdomain \"" + subdomain_name + "\" not found in mesh.");
          blocks.erase(id);
        }
        for (const auto id : blocks)
          local_mesh_subs.erase(id);
      }

      // also exclude mortar spaces from the material check
      auto && mortar_subdomain_ids = _mortar_data->getMortarSubdomainIDs();
      for (auto subdomain_id : mortar_subdomain_ids)
        local_mesh_subs.erase(subdomain_id);

      // Check Material Coverage
      if (check_material_coverage && !local_mesh_subs.empty())
      {
        std::stringstream extra_subdomain_ids;
        std::copy(local_mesh_subs.begin(),
                  local_mesh_subs.end(),
                  std::ostream_iterator<unsigned int>(extra_subdomain_ids, " "));
        std::vector<SubdomainID> local_mesh_subs_vec(local_mesh_subs.begin(),
                                                     local_mesh_subs.end());

        mooseError("The following blocks from your input mesh do not contain an active material: " +
                   extra_subdomain_ids.str() +
                   "(names: " + Moose::stringify(_mesh.getSubdomainNames(local_mesh_subs_vec)) +
                   ")\nWhen ANY mesh block contains a Material object, "
                   "all blocks must contain a Material object.\n");
      }
    }

    // Check material properties on blocks and boundaries
    checkBlockMatProps();
    checkBoundaryMatProps();

    // Check that material properties exist when requested by other properties on a given block
    const auto & materials = _all_materials.getActiveObjects();
    for (const auto & material : materials)
      material->checkStatefulSanity();

    // auto mats_to_check = _materials.getActiveBlockObjects();
    // const auto & discrete_materials = _discrete_materials.getActiveBlockObjects();
    // for (const auto & map_it : discrete_materials)
    //   for (const auto & container_element : map_it.second)
    //     mats_to_check[map_it.first].push_back(container_element);
    if (_material_dependency_check)
      checkDependMaterialsHelper(_all_materials.getActiveBlockObjects());
  }

  checkUserObjects();

  // Verify that we don't have any Element type/Coordinate Type conflicts
  checkCoordinateSystems();

  // Coordinate transforms are only intended for use with MultiApps at this time. If you are not
  // using multiapps but still require these, contact a moose developer
  if (_mesh.coordTransform().hasScalingOrRotationTransformation() && _app.isUltimateMaster() &&
      !hasMultiApps())
    mooseError("Coordinate transformation parameters, listed below, are only to be used in the "
               "context of application to application field transfers at this time. The mesh is "
               "not modified by these parameters within an application.\n"
               "You should likely use a 'TransformGenerator' in the [Mesh] block to achieve the "
               "desired mesh modification.\n\n",
               Moose::stringify(MooseAppCoordTransform::validParams()));

  // If using displacements, verify that the order of the displacement
  // variables matches the order of the elements in the displaced
  // mesh.
  checkDisplacementOrders();

  // Check for postprocessor names with same name as a scalar variable
  checkDuplicatePostprocessorVariableNames();
}

checkUserObjectJacobianRequirement()

void FEProblemBase::checkUserObjectJacobianRequirement ( THREAD_ID  tid )

inherited

Definition at line 1691 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

{
  std::set<const MooseVariableFEBase *> uo_jacobian_moose_vars;
  {
    std::vector<ShapeElementUserObject *> objs;
    theWarehouse()
        .query()
        .condition<AttribInterfaces>(Interfaces::ShapeElementUserObject)
        .condition<AttribThread>(tid)
        .queryInto(objs);

    for (const auto & uo : objs)
    {
      _calculate_jacobian_in_uo = uo->computeJacobianFlag();
      const auto & mv_deps = uo->jacobianMooseVariables();
      uo_jacobian_moose_vars.insert(mv_deps.begin(), mv_deps.end());
    }
  }
  {
    std::vector<ShapeSideUserObject *> objs;
    theWarehouse()
        .query()
        .condition<AttribInterfaces>(Interfaces::ShapeSideUserObject)
        .condition<AttribThread>(tid)
        .queryInto(objs);
    for (const auto & uo : objs)
    {
      _calculate_jacobian_in_uo = uo->computeJacobianFlag();
      const auto & mv_deps = uo->jacobianMooseVariables();
      uo_jacobian_moose_vars.insert(mv_deps.begin(), mv_deps.end());
    }
  }

  _uo_jacobian_moose_vars[tid].assign(uo_jacobian_moose_vars.begin(), uo_jacobian_moose_vars.end());
  std::sort(
      _uo_jacobian_moose_vars[tid].begin(), _uo_jacobian_moose_vars[tid].end(), sortMooseVariables);
}

checkUserObjects()

void FEProblemBase::checkUserObjects ( )

protectedinherited

Definition at line 8714 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

{
  // Check user_objects block coverage
  std::set<SubdomainID> mesh_subdomains = _mesh.meshSubdomains();
  std::set<SubdomainID> user_objects_blocks;

  // gather names of all user_objects that were defined in the input file
  // and the blocks that they are defined on
  std::set<std::string> names;

  std::vector<UserObject *> objects;
  theWarehouse().query().condition<AttribInterfaces>(Interfaces::UserObject).queryInto(objects);

  for (const auto & obj : objects)
    names.insert(obj->name());

  // See if all referenced blocks are covered
  std::set<SubdomainID> difference;
  std::set_difference(user_objects_blocks.begin(),
                      user_objects_blocks.end(),
                      mesh_subdomains.begin(),
                      mesh_subdomains.end(),
                      std::inserter(difference, difference.end()));

  if (!difference.empty())
  {
    std::ostringstream oss;
    oss << "One or more UserObjects is referencing a nonexistent block:\n";
    for (const auto & id : difference)
      oss << id << "\n";
    mooseError(oss.str());
  }
}

clearActiveElementalMooseVariables()

void FEProblemBase::clearActiveElementalMooseVariables ( const THREAD_ID  tid )

overridevirtualinherited

Clear the active elemental MooseVariableFEBase.

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 MooseVariableFEBases

Parameters

tid	The thread id

Reimplemented from SubProblem.

Definition at line 6064 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::post(), ComputeMarkerThread::post(), ComputeDiracThread::post(), ComputeIndicatorThread::post(), and ComputeUserObjectsThread::post().

{
  SubProblem::clearActiveElementalMooseVariables(tid);

  if (_displaced_problem)
    _displaced_problem->clearActiveElementalMooseVariables(tid);
}

clearActiveFEVariableCoupleableMatrixTags()

void FEProblemBase::clearActiveFEVariableCoupleableMatrixTags ( const THREAD_ID  tid )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6073 of file FEProblemBase.C.

{
  SubProblem::clearActiveFEVariableCoupleableMatrixTags(tid);

  if (_displaced_problem)
    _displaced_problem->clearActiveFEVariableCoupleableMatrixTags(tid);
}

clearActiveFEVariableCoupleableVectorTags()

void FEProblemBase::clearActiveFEVariableCoupleableVectorTags ( const THREAD_ID  tid )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6082 of file FEProblemBase.C.

{
  SubProblem::clearActiveFEVariableCoupleableVectorTags(tid);

  if (_displaced_problem)
    _displaced_problem->clearActiveFEVariableCoupleableVectorTags(tid);
}

clearActiveMaterialProperties()

void FEProblemBase::clearActiveMaterialProperties ( const THREAD_ID  tid )

inherited

Clear the active material properties.

Should be called at the end of every computing thread

Parameters

tid	The thread id

Definition at line 6130 of file FEProblemBase.C.

Referenced by NodalPatchRecovery::compute(), ComputeDiracThread::post(), ComputeIndicatorThread::post(), and ComputeUserObjectsThread::post().

{
  _has_active_material_properties[tid] = 0;
}

clearActiveScalarVariableCoupleableMatrixTags()

void FEProblemBase::clearActiveScalarVariableCoupleableMatrixTags ( const THREAD_ID  tid )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6091 of file FEProblemBase.C.

Referenced by AuxiliarySystem::clearScalarVariableCoupleableTags().

{
  SubProblem::clearActiveScalarVariableCoupleableMatrixTags(tid);

  if (_displaced_problem)
    _displaced_problem->clearActiveScalarVariableCoupleableMatrixTags(tid);
}

clearActiveScalarVariableCoupleableVectorTags()

void FEProblemBase::clearActiveScalarVariableCoupleableVectorTags ( const THREAD_ID  tid )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6100 of file FEProblemBase.C.

Referenced by AuxiliarySystem::clearScalarVariableCoupleableTags().

{
  SubProblem::clearActiveScalarVariableCoupleableVectorTags(tid);

  if (_displaced_problem)
    _displaced_problem->clearActiveScalarVariableCoupleableVectorTags(tid);
}

clearAllDofIndices()

void SubProblem::clearAllDofIndices ( )

inherited

Clear dof indices from variables in nl and aux systems.

Definition at line 1178 of file SubProblem.C.

Referenced by FEProblemBase::solve().

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

clearCurrentJacobianMatrixTags()

void FEProblemBase::clearCurrentJacobianMatrixTags ( )

inlineinherited

Clear the current Jacobian matrix tag data structure ...

if someone creates it

Definition at line 2670 of file FEProblemBase.h.

Referenced by FEProblemBase::resetState().

{}

clearCurrentResidualVectorTags()

void FEProblemBase::clearCurrentResidualVectorTags ( )

inlineinherited

Clear the current residual vector tag data structure.

Definition at line 3553 of file FEProblemBase.h.

Referenced by CrankNicolson::init(), and FEProblemBase::resetState().

{
  _current_residual_vector_tags.clear();
}

clearDiracInfo()

void FEProblemBase::clearDiracInfo ( )

overridevirtualinherited

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

Implements SubProblem.

Definition at line 2512 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeDiracContributions().

{
  _dirac_kernel_info.clearPoints();

  if (_displaced_problem)
    _displaced_problem->clearDiracInfo();
}

computeBounds()

void FEProblemBase::computeBounds ( libMesh::NonlinearImplicitSystem &  sys, NumericVector< libMesh::Number > &  lower, NumericVector< libMesh::Number > &  upper  )

virtualinherited

Definition at line 7685 of file FEProblemBase.C.

Referenced by Moose::compute_bounds().

{
  try
  {
    try
    {
      mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
                  "I expect these system numbers to be the same");

      if (!_current_nl_sys->hasVector("lower_bound") || !_current_nl_sys->hasVector("upper_bound"))
        return;

      TIME_SECTION("computeBounds", 1, "Computing Bounds");

      NumericVector<Number> & _lower = _current_nl_sys->getVector("lower_bound");
      NumericVector<Number> & _upper = _current_nl_sys->getVector("upper_bound");
      _lower.swap(lower);
      _upper.swap(upper);
      for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
        _all_materials.residualSetup(tid);

      _aux->residualSetup();
      computeSystems(EXEC_LINEAR);
      _lower.swap(lower);
      _upper.swap(upper);
    }
    catch (...)
    {
      handleException("computeBounds");
    }
  }
  catch (MooseException & e)
  {
    mooseError("Irrecoverable exception: " + std::string(e.what()));
  }
  catch (...)
  {
    mooseError("Unexpected exception type");
  }
}

computeDamping()

Real FEProblemBase::computeDamping ( const NumericVector< libMesh::Number > &  soln, const NumericVector< libMesh::Number > &  update  )

virtualinherited

Definition at line 7964 of file FEProblemBase.C.

Referenced by FEProblemBase::computePostCheck().

{
  // Default to no damping
  Real damping = 1.0;

  if (_has_dampers)
  {
    TIME_SECTION("computeDamping", 1, "Computing Damping");

    // Save pointer to the current solution
    const NumericVector<Number> * _saved_current_solution = _current_nl_sys->currentSolution();

    _current_nl_sys->setSolution(soln);
    // For now, do not re-compute auxiliary variables.  Doing so allows a wild solution increment
    //   to get to the material models, which may not be able to cope with drastically different
    //   values.  Once more complete dependency checking is in place, auxiliary variables (and
    //   material properties) will be computed as needed by dampers.
    //    _aux.compute();
    damping = _current_nl_sys->computeDamping(soln, update);

    // restore saved solution
    _current_nl_sys->setSolution(*_saved_current_solution);
  }

  return damping;
}

computeIndicators()

void FEProblemBase::computeIndicators ( )

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 4703 of file FEProblemBase.C.

Referenced by FEProblemBase::computeIndicatorsAndMarkers(), TransientBase::endStep(), MFEMSteady::execute(), SteadyBase::execute(), Eigenvalue::execute(), and FEProblemBase::initialAdaptMesh().

{
  // Initialize indicator aux variable fields
  if (_indicators.hasActiveObjects() || _internal_side_indicators.hasActiveObjects())
  {
    TIME_SECTION("computeIndicators", 1, "Computing Indicators");

    // Internal side indicators may lead to creating a much larger sparsity pattern than dictated by
    // the actual finite element scheme (e.g. CFEM)
    const auto old_do_derivatives = ADReal::do_derivatives;
    ADReal::do_derivatives = false;

    std::vector<std::string> fields;

    // Indicator Fields
    const auto & indicators = _indicators.getActiveObjects();
    for (const auto & indicator : indicators)
      fields.push_back(indicator->name());

    // InternalSideIndicator Fields
    const auto & internal_indicators = _internal_side_indicators.getActiveObjects();
    for (const auto & internal_indicator : internal_indicators)
      fields.push_back(internal_indicator->name());

    _aux->zeroVariables(fields);

    // compute Indicators
    ComputeIndicatorThread cit(*this);
    Threads::parallel_reduce(*_mesh.getActiveLocalElementRange(), cit);
    _aux->solution().close();
    _aux->update();

    ComputeIndicatorThread finalize_cit(*this, true);
    Threads::parallel_reduce(*_mesh.getActiveLocalElementRange(), finalize_cit);
    _aux->solution().close();
    _aux->update();

    ADReal::do_derivatives = old_do_derivatives;
  }
}

computeIndicatorsAndMarkers()

void FEProblemBase::computeIndicatorsAndMarkers ( )

virtualinherited

Definition at line 4696 of file FEProblemBase.C.

{
  computeIndicators();
  computeMarkers();
}

computeJacobian()

void FEProblemBase::computeJacobian ( const NumericVector< libMesh::Number > &  soln, libMesh::SparseMatrix< libMesh::Number > &  jacobian, const unsigned int  nl_sys_num  )

virtualinherited

Form a Jacobian matrix with the default tag (system).

Definition at line 7520 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobianSys().

{
  setCurrentNonlinearSystem(nl_sys_num);

  _fe_matrix_tags.clear();

  auto & tags = getMatrixTags();
  for (auto & tag : tags)
    _fe_matrix_tags.insert(tag.second);

  computeJacobianInternal(soln, jacobian, _fe_matrix_tags);
}

computeJacobianBlock()

void FEProblemBase::computeJacobianBlock ( libMesh::SparseMatrix< libMesh::Number > &  jacobian, libMesh::System &  precond_system, unsigned int  ivar, unsigned int  jvar  )

virtualinherited

Really not a good idea to use this.

It computes just one block of the Jacobian into a smaller matrix. Calling this in a loop is EXTREMELY ineffecient! Try to use computeJacobianBlocks() instead!

Parameters

jacobian	The matrix you want to fill
precond_system	The libMesh::system of the preconditioning system
ivar	the block-row of the Jacobian
jvar	the block-column of the Jacobian

Definition at line 7673 of file FEProblemBase.C.

{
  JacobianBlock jac_block(precond_system, jacobian, ivar, jvar);
  std::vector<JacobianBlock *> blocks = {&jac_block};
  mooseAssert(_current_nl_sys, "This should be non-null");
  computeJacobianBlocks(blocks, _current_nl_sys->number());
}

computeJacobianBlocks()

void FEProblemBase::computeJacobianBlocks ( std::vector< JacobianBlock *> &  blocks, const unsigned int  nl_sys_num  )

virtualinherited

Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditioning matrices.

Used by Physics-based preconditioning

Parameters

blocks

The blocks to fill in (JacobianBlock is defined in ComputeJacobianBlocksThread)

Reimplemented in EigenProblem.

Definition at line 7653 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobianBlock(), and PhysicsBasedPreconditioner::setup().

{
  TIME_SECTION("computeTransientImplicitJacobian", 2);
  setCurrentNonlinearSystem(nl_sys_num);

  if (_displaced_problem)
  {
    computeSystems(EXEC_PRE_DISPLACE);
    _displaced_problem->updateMesh();
  }

  computeSystems(EXEC_NONLINEAR);

  _currently_computing_jacobian = true;
  _current_nl_sys->computeJacobianBlocks(blocks);
  _currently_computing_jacobian = false;
}

computeJacobianInternal()

void FEProblemBase::computeJacobianInternal ( const NumericVector< libMesh::Number > &  soln, libMesh::SparseMatrix< libMesh::Number > &  jacobian, const std::set< TagID > &  tags  )

virtualinherited

Form a Jacobian matrix for multiple tags.

It should not be called directly by users.

Definition at line 7536 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobian().

{
  TIME_SECTION("computeJacobianInternal", 1);

  _current_nl_sys->setSolution(soln);

  _current_nl_sys->associateMatrixToTag(jacobian, _current_nl_sys->systemMatrixTag());

  computeJacobianTags(tags);

  _current_nl_sys->disassociateMatrixFromTag(jacobian, _current_nl_sys->systemMatrixTag());
}

computeJacobianSys()

void FEProblemBase::computeJacobianSys ( libMesh::NonlinearImplicitSystem &  sys, const NumericVector< libMesh::Number > &  soln, libMesh::SparseMatrix< libMesh::Number > &  jacobian  )

virtualinherited

Form a Jacobian matrix.

It is called by Libmesh.

Definition at line 7498 of file FEProblemBase.C.

Referenced by Moose::compute_jacobian(), and NonlinearSystem::computeScalingJacobian().

{
  computeJacobian(soln, jacobian, sys.number());
}

computeJacobianTag()

void FEProblemBase::computeJacobianTag ( const NumericVector< libMesh::Number > &  soln, libMesh::SparseMatrix< libMesh::Number > &  jacobian, TagID  tag  )

virtualinherited

Form a Jacobian matrix for a given tag.

Definition at line 7506 of file FEProblemBase.C.

Referenced by ActuallyExplicitEuler::solve(), and ExplicitSSPRungeKutta::solveStage().

{
  _current_nl_sys->setSolution(soln);

  _current_nl_sys->associateMatrixToTag(jacobian, tag);

  computeJacobianTags({tag});

  _current_nl_sys->disassociateMatrixFromTag(jacobian, tag);
}

computeJacobianTags()

void FEProblemBase::computeJacobianTags ( const std::set< TagID > &  tags )

virtualinherited

Form multiple matrices, and each is associated with a tag.

Definition at line 7552 of file FEProblemBase.C.

Referenced by EigenProblem::computeJacobianAB(), FEProblemBase::computeJacobianInternal(), EigenProblem::computeJacobianTag(), FEProblemBase::computeJacobianTag(), and EigenProblem::computeMatricesTags().

{
  try
  {
    try
    {
      if (!_has_jacobian || !_const_jacobian)
      {
        TIME_SECTION("computeJacobianTags", 5, "Computing Jacobian");

        for (auto tag : tags)
          if (_current_nl_sys->hasMatrix(tag))
          {
            auto & matrix = _current_nl_sys->getMatrix(tag);
            if (_restore_original_nonzero_pattern)
              matrix.restore_original_nonzero_pattern();
            else
              matrix.zero();
            if (haveADObjects() && !_current_nl_sys->system().has_static_condensation())
              // PETSc algorithms require diagonal allocations regardless of whether there is
              // non-zero diagonal dependence. With global AD indexing we only add non-zero
              // dependence, so PETSc will scream at us unless we artificially add the diagonals.
              for (auto index : make_range(matrix.row_start(), matrix.row_stop()))
                matrix.add(index, index, 0);
          }

        _aux->zeroVariablesForJacobian();

        unsigned int n_threads = libMesh::n_threads();

        // Random interface objects
        for (const auto & it : _random_data_objects)
          it.second->updateSeeds(EXEC_NONLINEAR);

        _current_execute_on_flag = EXEC_NONLINEAR;
        _currently_computing_jacobian = true;
        if (_displaced_problem)
          _displaced_problem->setCurrentlyComputingJacobian(true);

        execTransfers(EXEC_NONLINEAR);
        execMultiApps(EXEC_NONLINEAR);

        for (unsigned int tid = 0; tid < n_threads; tid++)
          reinitScalars(tid);

        computeUserObjects(EXEC_NONLINEAR, Moose::PRE_AUX);

        _aux->jacobianSetup();

        if (_displaced_problem)
        {
          computeSystems(EXEC_PRE_DISPLACE);
          _displaced_problem->updateMesh();
        }

        for (unsigned int tid = 0; tid < n_threads; tid++)
        {
          _all_materials.jacobianSetup(tid);
          _functions.jacobianSetup(tid);
        }

        computeSystems(EXEC_NONLINEAR);

        computeUserObjects(EXEC_NONLINEAR, Moose::POST_AUX);

        executeControls(EXEC_NONLINEAR);

        _app.getOutputWarehouse().jacobianSetup();

        _safe_access_tagged_matrices = false;

        _current_nl_sys->computeJacobianTags(tags);

        // For explicit Euler calculations for example we often compute the Jacobian one time and
        // then re-use it over and over. If we're performing automatic scaling, we don't want to
        // use that kernel, diagonal-block only Jacobian for our actual matrix when performing
        // solves!
        if (!_current_nl_sys->computingScalingJacobian())
          _has_jacobian = true;
      }
    }
    catch (...)
    {
      handleException("computeJacobianTags");
    }
  }
  catch (const MooseException &)
  {
    // The buck stops here, we have already handled the exception by
    // calling the system's stopSolve() method, it is now up to PETSc to return a
    // "diverged" reason during the next solve.
  }
  catch (...)
  {
    mooseError("Unexpected exception type");
  }

  resetState();
}

computeLinearSystemSys()

void FEProblemBase::computeLinearSystemSys ( libMesh::LinearImplicitSystem &  sys, libMesh::SparseMatrix< libMesh::Number > &  system_matrix, NumericVector< libMesh::Number > &  rhs, const bool  compute_gradients = true  )

virtualinherited

Assemble both the right hand side and the system matrix of a given linear system.

Parameters

sys	The linear system which should be assembled
system_matrix	The sparse matrix which should hold the system matrix
rhs	The vector which should hold the right hand side
compute_gradients	A flag to disable the computation of new gradients during the assembly, can be used to lag gradients

Definition at line 7729 of file FEProblemBase.C.

Referenced by Moose::compute_linear_system(), and FEProblemBase::computeResidualL2Norm().

{
  TIME_SECTION("computeLinearSystemSys", 5);

  setCurrentLinearSystem(linearSysNum(sys.name()));

  _current_linear_sys->associateVectorToTag(rhs, _current_linear_sys->rightHandSideVectorTag());
  _current_linear_sys->associateMatrixToTag(system_matrix, _current_linear_sys->systemMatrixTag());

  // We are using the residual tag system for right hand sides so we fetch everything
  const auto & vector_tags = getVectorTags(Moose::VECTOR_TAG_RESIDUAL);

  // We filter out tags which do not have associated vectors in the current
  // system. This is essential to be able to use system-dependent vector tags.
  selectVectorTagsFromSystem(*_current_linear_sys, vector_tags, _linear_vector_tags);
  selectMatrixTagsFromSystem(*_current_linear_sys, getMatrixTags(), _linear_matrix_tags);

  computeLinearSystemTags(*(_current_linear_sys->currentSolution()),
                          _linear_vector_tags,
                          _linear_matrix_tags,
                          compute_gradients);

  _current_linear_sys->disassociateMatrixFromTag(system_matrix,
                                                 _current_linear_sys->systemMatrixTag());
  _current_linear_sys->disassociateVectorFromTag(rhs,
                                                 _current_linear_sys->rightHandSideVectorTag());
  // We reset the tags to the default containers for further operations
  _current_linear_sys->associateVectorToTag(_current_linear_sys->getRightHandSideVector(),
                                            _current_linear_sys->rightHandSideVectorTag());
  _current_linear_sys->associateMatrixToTag(_current_linear_sys->getSystemMatrix(),
                                            _current_linear_sys->systemMatrixTag());
}

computeLinearSystemTags()

void FEProblemBase::computeLinearSystemTags ( const NumericVector< libMesh::Number > &  soln, const std::set< TagID > &  vector_tags, const std::set< TagID > &  matrix_tags, const bool  compute_gradients = true  )

inherited

Assemble the current linear system given a set of vector and matrix tags.

Parameters

soln	The solution which should be used for the system assembly
vector_tags	The vector tags for the right hand side
matrix_tags	The matrix tags for the matrix
compute_gradients	A flag to disable the computation of new gradients during the assembly, can be used to lag gradients

Definition at line 7766 of file FEProblemBase.C.

Referenced by FEProblemBase::computeLinearSystemSys().

{
  TIME_SECTION("computeLinearSystemTags", 5, "Computing Linear System");

  _current_linear_sys->setSolution(soln);

  for (auto tag : matrix_tags)
  {
    auto & matrix = _current_linear_sys->getMatrix(tag);
    matrix.zero();
  }

  unsigned int n_threads = libMesh::n_threads();

  _current_execute_on_flag = EXEC_NONLINEAR;

  // Random interface objects
  for (const auto & it : _random_data_objects)
    it.second->updateSeeds(EXEC_NONLINEAR);

  execTransfers(EXEC_NONLINEAR);
  execMultiApps(EXEC_NONLINEAR);

  computeUserObjects(EXEC_NONLINEAR, Moose::PRE_AUX);

  _aux->jacobianSetup();

  for (THREAD_ID tid = 0; tid < n_threads; tid++)
  {
    _functions.jacobianSetup(tid);
  }

  try
  {
    computeSystems(EXEC_NONLINEAR);
  }
  catch (MooseException & e)
  {
    _console << "\nA MooseException was raised during Auxiliary variable computation.\n"
             << "The next solve will fail, the timestep will be reduced, and we will try again.\n"
             << std::endl;

    // We know the next solve is going to fail, so there's no point in
    // computing anything else after this.  Plus, using incompletely
    // computed AuxVariables in subsequent calculations could lead to
    // other errors or unhandled exceptions being thrown.
    return;
  }

  computeUserObjects(EXEC_NONLINEAR, Moose::POST_AUX);
  executeControls(EXEC_NONLINEAR);

  _app.getOutputWarehouse().jacobianSetup();

  _current_linear_sys->computeLinearSystemTags(vector_tags, matrix_tags, compute_gradients);

  // Reset execution flag as after this point we are no longer on LINEAR
  _current_execute_on_flag = EXEC_NONE;

  // These are the relevant parts of resetState()
  _safe_access_tagged_vectors = true;
  _safe_access_tagged_matrices = true;
}

computeMarkers()

void FEProblemBase::computeMarkers ( )

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 4745 of file FEProblemBase.C.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::computeIndicatorsAndMarkers(), TransientBase::endStep(), MFEMSteady::execute(), SteadyBase::execute(), Eigenvalue::execute(), and FEProblemBase::initialAdaptMesh().

{
  if (_markers.hasActiveObjects())
  {
    TIME_SECTION("computeMarkers", 1, "Computing Markers");

    std::vector<std::string> fields;

    // Marker Fields
    const auto & markers = _markers.getActiveObjects();
    for (const auto & marker : markers)
      fields.push_back(marker->name());

    _aux->zeroVariables(fields);

    _adaptivity.updateErrorVectors();

    for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
    {
      const auto & markers = _markers.getActiveObjects(tid);
      for (const auto & marker : markers)
        marker->markerSetup();
    }

    ComputeMarkerThread cmt(*this);
    Threads::parallel_reduce(*_mesh.getActiveLocalElementRange(), cmt);

    _aux->solution().close();
    _aux->update();
  }
}

computeMultiAppsDT()

Real FEProblemBase::computeMultiAppsDT ( ExecFlagType  type )

inherited

Find the smallest timestep over all MultiApps.

Definition at line 5795 of file FEProblemBase.C.

Referenced by TransientBase::constrainDTFromMultiApp().

{
  const auto & multi_apps = _transient_multi_apps[type].getActiveObjects();

  Real smallest_dt = std::numeric_limits<Real>::max();

  for (const auto & multi_app : multi_apps)
    smallest_dt = std::min(smallest_dt, multi_app->computeDT());

  return smallest_dt;
}

computeNearNullSpace()

void FEProblemBase::computeNearNullSpace ( libMesh::NonlinearImplicitSystem &  sys, std::vector< NumericVector< libMesh::Number > *> &  sp  )

virtualinherited

Definition at line 7834 of file FEProblemBase.C.

Referenced by Moose::compute_nearnullspace().

{
  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
              "I expect these system numbers to be the same");

  sp.clear();
  for (unsigned int i = 0; i < subspaceDim("NearNullSpace"); ++i)
  {
    std::stringstream postfix;
    postfix << "_" << i;
    std::string modename = "NearNullSpace" + postfix.str();
    sp.push_back(&_current_nl_sys->getVector(modename));
  }
}

computeNullSpace()

void FEProblemBase::computeNullSpace ( libMesh::NonlinearImplicitSystem &  sys, std::vector< NumericVector< libMesh::Number > *> &  sp  )

virtualinherited

Definition at line 7851 of file FEProblemBase.C.

Referenced by Moose::compute_nullspace().

{
  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
              "I expect these system numbers to be the same");
  sp.clear();
  for (unsigned int i = 0; i < subspaceDim("NullSpace"); ++i)
  {
    std::stringstream postfix;
    postfix << "_" << i;
    sp.push_back(&_current_nl_sys->getVector("NullSpace" + postfix.str()));
  }
}

computePostCheck()

void FEProblemBase::computePostCheck ( libMesh::NonlinearImplicitSystem &  sys, const NumericVector< libMesh::Number > &  old_soln, NumericVector< libMesh::Number > &  search_direction, NumericVector< libMesh::Number > &  new_soln, bool &  changed_search_direction, bool &  changed_new_soln  )

virtualinherited

Definition at line 7881 of file FEProblemBase.C.

Referenced by Moose::compute_postcheck().

{
  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
              "I expect these system numbers to be the same");

  // This function replaces the old PetscSupport::dampedCheck() function.
  //
  // 1.) Recreate code in PetscSupport::dampedCheck() for constructing
  //     ghosted "soln" and "update" vectors.
  // 2.) Call FEProblemBase::computeDamping() with these ghost vectors.
  // 3.) Recreate the code in PetscSupport::dampedCheck() to actually update
  //     the solution vector based on the damping, and set the "changed" flags
  //     appropriately.

  TIME_SECTION("computePostCheck", 2, "Computing Post Check");

  _current_execute_on_flag = EXEC_POSTCHECK;

  // MOOSE's FEProblemBase doesn't update the solution during the
  // postcheck, but FEProblemBase-derived classes might.
  if (_has_dampers || shouldUpdateSolution())
  {
    // We need ghosted versions of new_soln and search_direction (the
    // ones we get from libmesh/PETSc are PARALLEL vectors.  To make
    // our lives simpler, we use the same ghosting pattern as the
    // system's current_local_solution to create new ghosted vectors.

    // Construct zeroed-out clones with the same ghosted dofs as the
    // System's current_local_solution.
    std::unique_ptr<NumericVector<Number>> ghosted_solution =
                                               sys.current_local_solution->zero_clone(),
                                           ghosted_search_direction =
                                               sys.current_local_solution->zero_clone();

    // Copy values from input vectors into clones with ghosted values.
    *ghosted_solution = new_soln;
    *ghosted_search_direction = search_direction;

    if (_has_dampers)
    {
      // Compute the damping coefficient using the ghosted vectors
      Real damping = computeDamping(*ghosted_solution, *ghosted_search_direction);

      // If some non-trivial damping was computed, update the new_soln
      // vector accordingly.
      if (damping < 1.0)
      {
        new_soln = old_soln;
        new_soln.add(-damping, search_direction);
        changed_new_soln = true;
      }
    }

    if (shouldUpdateSolution())
    {
      // Update the ghosted copy of the new solution, if necessary.
      if (changed_new_soln)
        *ghosted_solution = new_soln;

      bool updated_solution = updateSolution(new_soln, *ghosted_solution);
      if (updated_solution)
        changed_new_soln = true;
    }
  }

  if (vectorTagExists(Moose::PREVIOUS_NL_SOLUTION_TAG))
  {
    _current_nl_sys->setPreviousNewtonSolution(old_soln);
    _aux->copyCurrentIntoPreviousNL();
  }

  // MOOSE doesn't change the search_direction
  changed_search_direction = false;

  _current_execute_on_flag = EXEC_NONE;
}

computeResidual() [1/2]

void FEProblemBase::computeResidual ( libMesh::NonlinearImplicitSystem &  sys, const NumericVector< libMesh::Number > &  soln, NumericVector< libMesh::Number > &  residual  )

inherited

This function is called by Libmesh to form a residual.

This is deprecated. We should remove this as soon as RattleSnake is fixed.

Referenced by FEProblemBase::computeResidualL2Norm(), FEProblemBase::computeResidualSys(), ActuallyExplicitEuler::solve(), and ExplicitSSPRungeKutta::solveStage().

computeResidual() [2/2]

virtual void FEProblemBase::computeResidual ( const NumericVector< libMesh::Number > &  soln, NumericVector< libMesh::Number > &  residual, const unsigned int  nl_sys_num  )

virtualinherited

Form a residual with default tags (nontime, time, residual).

computeResidualAndJacobian()

void FEProblemBase::computeResidualAndJacobian ( const NumericVector< libMesh::Number > &  soln, NumericVector< libMesh::Number > &  residual, libMesh::SparseMatrix< libMesh::Number > &  jacobian  )

inherited

Form a residual and Jacobian with default tags.

Definition at line 7143 of file FEProblemBase.C.

Referenced by ComputeResidualAndJacobian::residual_and_jacobian().

{
  try
  {
    try
    {
      // vector tags
      _current_nl_sys->associateVectorToTag(residual, _current_nl_sys->residualVectorTag());
      const auto & residual_vector_tags = getVectorTags(Moose::VECTOR_TAG_RESIDUAL);

      mooseAssert(_fe_vector_tags.empty(),
                  "This should be empty indicating a clean starting state");
      // We filter out tags which do not have associated vectors in the current nonlinear
      // system. This is essential to be able to use system-dependent residual tags.
      selectVectorTagsFromSystem(*_current_nl_sys, residual_vector_tags, _fe_vector_tags);

      setCurrentResidualVectorTags(_fe_vector_tags);

      // matrix tags
      {
        _fe_matrix_tags.clear();

        auto & tags = getMatrixTags();
        for (auto & tag : tags)
          _fe_matrix_tags.insert(tag.second);
      }

      _current_nl_sys->setSolution(soln);

      _current_nl_sys->associateVectorToTag(residual, _current_nl_sys->residualVectorTag());
      _current_nl_sys->associateMatrixToTag(jacobian, _current_nl_sys->systemMatrixTag());

      for (const auto tag : _fe_matrix_tags)
        if (_current_nl_sys->hasMatrix(tag))
        {
          auto & matrix = _current_nl_sys->getMatrix(tag);
          matrix.zero();
          if (haveADObjects() && !_current_nl_sys->system().has_static_condensation())
            // PETSc algorithms require diagonal allocations regardless of whether there is non-zero
            // diagonal dependence. With global AD indexing we only add non-zero
            // dependence, so PETSc will scream at us unless we artificially add the diagonals.
            for (auto index : make_range(matrix.row_start(), matrix.row_stop()))
              matrix.add(index, index, 0);
        }

      _aux->zeroVariablesForResidual();

      unsigned int n_threads = libMesh::n_threads();

      _current_execute_on_flag = EXEC_LINEAR;

      // Random interface objects
      for (const auto & it : _random_data_objects)
        it.second->updateSeeds(EXEC_LINEAR);

      setCurrentlyComputingResidual(true);
      setCurrentlyComputingJacobian(true);
      setCurrentlyComputingResidualAndJacobian(true);
      if (_displaced_problem)
      {
        _displaced_problem->setCurrentlyComputingResidual(true);
        _displaced_problem->setCurrentlyComputingJacobian(true);
        _displaced_problem->setCurrentlyComputingResidualAndJacobian(true);
      }

      execTransfers(EXEC_LINEAR);

      execMultiApps(EXEC_LINEAR);

      for (unsigned int tid = 0; tid < n_threads; tid++)
        reinitScalars(tid);

      computeUserObjects(EXEC_LINEAR, Moose::PRE_AUX);

      _aux->residualSetup();

      if (_displaced_problem)
      {
        computeSystems(EXEC_PRE_DISPLACE);
        _displaced_problem->updateMesh();
        if (_mortar_data->hasDisplacedObjects())
          updateMortarMesh();
      }

      for (THREAD_ID tid = 0; tid < n_threads; tid++)
      {
        _all_materials.residualSetup(tid);
        _functions.residualSetup(tid);
      }

      computeSystems(EXEC_LINEAR);

      computeUserObjects(EXEC_LINEAR, Moose::POST_AUX);

      executeControls(EXEC_LINEAR);

      _app.getOutputWarehouse().residualSetup();

      _safe_access_tagged_vectors = false;
      _safe_access_tagged_matrices = false;

      _current_nl_sys->computeResidualAndJacobianTags(_fe_vector_tags, _fe_matrix_tags);

      _current_nl_sys->disassociateMatrixFromTag(jacobian, _current_nl_sys->systemMatrixTag());
      _current_nl_sys->disassociateVectorFromTag(residual, _current_nl_sys->residualVectorTag());
    }
    catch (...)
    {
      handleException("computeResidualAndJacobian");
    }
  }
  catch (const MooseException &)
  {
    // The buck stops here, we have already handled the exception by
    // calling the system's stopSolve() method, it is now up to PETSc to return a
    // "diverged" reason during the next solve.
  }
  catch (...)
  {
    mooseError("Unexpected exception type");
  }

  resetState();
  _fe_vector_tags.clear();
  _fe_matrix_tags.clear();
}

computeResidualInternal()

void FEProblemBase::computeResidualInternal ( const NumericVector< libMesh::Number > &  soln, NumericVector< libMesh::Number > &  residual, const std::set< TagID > &  tags  )

virtualinherited

Form a residual vector for a set of tags.

It should not be called directly by users.

Definition at line 7302 of file FEProblemBase.C.

{
  parallel_object_only();

  TIME_SECTION("computeResidualInternal", 1);

  try
  {
    _current_nl_sys->setSolution(soln);

    _current_nl_sys->associateVectorToTag(residual, _current_nl_sys->residualVectorTag());

    computeResidualTags(tags);

    _current_nl_sys->disassociateVectorFromTag(residual, _current_nl_sys->residualVectorTag());
  }
  catch (MooseException & e)
  {
    // If a MooseException propagates all the way to here, it means
    // that it was thrown from a MOOSE system where we do not
    // (currently) properly support the throwing of exceptions, and
    // therefore we have no choice but to error out.  It may be
    // *possible* to handle exceptions from other systems, but in the
    // meantime, we don't want to silently swallow any unhandled
    // exceptions here.
    mooseError("An unhandled MooseException was raised during residual computation.  Please "
               "contact the MOOSE team for assistance.");
  }
}

computeResidualL2Norm() [1/3]

Real FEProblemBase::computeResidualL2Norm ( NonlinearSystemBase &  sys )

inherited

Computes the residual of a nonlinear system using whatever is sitting in the current solution vector then returns the L2 norm.

Definition at line 7052 of file FEProblemBase.C.

Referenced by DefaultMultiAppFixedPointConvergence::checkConvergence(), Residual::getValue(), DefaultMultiAppFixedPointConvergence::initialize(), and DefaultMultiAppFixedPointConvergence::preExecute().

{
  _current_nl_sys = &sys;
  computeResidual(*sys.currentSolution(), sys.RHS(), sys.number());
  return sys.RHS().l2_norm();
}

computeResidualL2Norm() [2/3]

Real FEProblemBase::computeResidualL2Norm ( LinearSystem &  sys )

inherited

Computes the residual of a linear system using whatever is sitting in the current solution vector then returns the L2 norm.

Definition at line 7060 of file FEProblemBase.C.

{
  _current_linear_sys = &sys;

  // We assemble the current system to check the current residual
  computeLinearSystemSys(sys.linearImplicitSystem(),
                         *sys.linearImplicitSystem().matrix,
                         *sys.linearImplicitSystem().rhs,
                         /*compute fresh gradients*/ true);

  // Unfortunate, but we have to allocate a new vector for the residual
  auto residual = sys.linearImplicitSystem().rhs->clone();
  residual->scale(-1.0);
  residual->add_vector(*sys.currentSolution(), *sys.linearImplicitSystem().matrix);
  return residual->l2_norm();
}

computeResidualL2Norm() [3/3]

Real FEProblemBase::computeResidualL2Norm ( )

virtualinherited

Computes the residual using whatever is sitting in the current solution vector then returns the L2 norm.

Returns

The L2 norm of the residual

Reimplemented in EigenProblem.

Definition at line 7078 of file FEProblemBase.C.

{
  TIME_SECTION("computeResidualL2Norm", 2, "Computing L2 Norm of Residual");

  // We use sum the squared norms of the individual systems and then take the square root of it
  Real l2_norm = 0.0;
  for (auto sys : _nl)
  {
    const auto norm = computeResidualL2Norm(*sys);
    l2_norm += norm * norm;
  }

  for (auto sys : _linear_systems)
  {
    const auto norm = computeResidualL2Norm(*sys);
    l2_norm += norm * norm;
  }

  return std::sqrt(l2_norm);
}

computeResidualSys()

void FEProblemBase::computeResidualSys ( libMesh::NonlinearImplicitSystem &  sys, const NumericVector< libMesh::Number > &  soln, NumericVector< libMesh::Number > &  residual  )

virtualinherited

This function is called by Libmesh to form a residual.

Definition at line 7100 of file FEProblemBase.C.

Referenced by NonlinearSystem::computeScalingResidual(), ComputeResidualFunctor::residual(), ComputeFDResidualFunctor::residual(), and NonlinearSystem::solve().

{
  parallel_object_only();

  TIME_SECTION("computeResidualSys", 5);

  computeResidual(soln, residual, sys.number());
}

computeResidualTag()

void FEProblemBase::computeResidualTag ( const NumericVector< libMesh::Number > &  soln, NumericVector< libMesh::Number > &  residual, TagID  tag  )

virtualinherited

Form a residual vector for a given tag.

Definition at line 7273 of file FEProblemBase.C.

{
  try
  {
    _current_nl_sys->setSolution(soln);

    _current_nl_sys->associateVectorToTag(residual, tag);

    computeResidualTags({tag});

    _current_nl_sys->disassociateVectorFromTag(residual, tag);
  }
  catch (MooseException & e)
  {
    // If a MooseException propagates all the way to here, it means
    // that it was thrown from a MOOSE system where we do not
    // (currently) properly support the throwing of exceptions, and
    // therefore we have no choice but to error out.  It may be
    // *possible* to handle exceptions from other systems, but in the
    // meantime, we don't want to silently swallow any unhandled
    // exceptions here.
    mooseError("An unhandled MooseException was raised during residual computation.  Please "
               "contact the MOOSE team for assistance.");
  }
}

computeResidualTags()

void FEProblemBase::computeResidualTags ( const std::set< TagID > &  tags )

virtualinherited

Form multiple residual vectors and each is associated with one tag.

Definition at line 7418 of file FEProblemBase.C.

Referenced by EigenProblem::computeResidualAB(), FEProblemBase::computeResidualInternal(), EigenProblem::computeResidualTag(), FEProblemBase::computeResidualTag(), and FEProblemBase::computeResidualType().

{
  parallel_object_only();

  try
  {
    try
    {
      TIME_SECTION("computeResidualTags", 5, "Computing Residual");

      ADReal::do_derivatives = false;

      setCurrentResidualVectorTags(tags);

      _aux->zeroVariablesForResidual();

      unsigned int n_threads = libMesh::n_threads();

      _current_execute_on_flag = EXEC_LINEAR;

      // Random interface objects
      for (const auto & it : _random_data_objects)
        it.second->updateSeeds(EXEC_LINEAR);

      execTransfers(EXEC_LINEAR);

      execMultiApps(EXEC_LINEAR);

      for (unsigned int tid = 0; tid < n_threads; tid++)
        reinitScalars(tid);

      computeUserObjects(EXEC_LINEAR, Moose::PRE_AUX);

      _aux->residualSetup();

      if (_displaced_problem)
      {
        computeSystems(EXEC_PRE_DISPLACE);
        _displaced_problem->updateMesh();
        if (_mortar_data->hasDisplacedObjects())
          updateMortarMesh();
      }

      for (THREAD_ID tid = 0; tid < n_threads; tid++)
      {
        _all_materials.residualSetup(tid);
        _functions.residualSetup(tid);
      }

      computeSystems(EXEC_LINEAR);

      computeUserObjects(EXEC_LINEAR, Moose::POST_AUX);

      executeControls(EXEC_LINEAR);

      _app.getOutputWarehouse().residualSetup();

      _safe_access_tagged_vectors = false;
      _current_nl_sys->computeResidualTags(tags);
    }
    catch (...)
    {
      handleException("computeResidualTags");
    }
  }
  catch (const MooseException &)
  {
    // The buck stops here, we have already handled the exception by
    // calling the system's stopSolve() method, it is now up to PETSc to return a
    // "diverged" reason during the next solve.
  }
  catch (...)
  {
    mooseError("Unexpected exception type");
  }

  resetState();
}

computeResidualType()

void FEProblemBase::computeResidualType ( const NumericVector< libMesh::Number > &  soln, NumericVector< libMesh::Number > &  residual, TagID  tag  )

virtualinherited

Form a residual vector for a given tag and "residual" tag.

Definition at line 7335 of file FEProblemBase.C.

{
  TIME_SECTION("computeResidualType", 5);

  try
  {
    _current_nl_sys->setSolution(soln);

    _current_nl_sys->associateVectorToTag(residual, _current_nl_sys->residualVectorTag());

    computeResidualTags({tag, _current_nl_sys->residualVectorTag()});

    _current_nl_sys->disassociateVectorFromTag(residual, _current_nl_sys->residualVectorTag());
  }
  catch (MooseException & e)
  {
    // If a MooseException propagates all the way to here, it means
    // that it was thrown from a MOOSE system where we do not
    // (currently) properly support the throwing of exceptions, and
    // therefore we have no choice but to error out.  It may be
    // *possible* to handle exceptions from other systems, but in the
    // meantime, we don't want to silently swallow any unhandled
    // exceptions here.
    mooseError("An unhandled MooseException was raised during residual computation.  Please "
               "contact the MOOSE team for assistance.");
  }
}

computeSystems()

void FEProblemBase::computeSystems ( const ExecFlagType &  type )

protectedinherited

Do generic system computations.

Definition at line 9592 of file FEProblemBase.C.

Referenced by FEProblemBase::computeBounds(), EigenProblem::computeJacobianBlocks(), FEProblemBase::computeJacobianBlocks(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), and FEProblemBase::execute().

{
  // When performing an adjoint solve in the optimization module, the current solver system is the
  // adjoint. However, the adjoint solve requires having accurate time derivative calculations for
  // the forward system. The cleanest way to handle such uses is just to compute the time
  // derivatives for all solver systems instead of trying to guess which ones we need and don't need
  for (auto & solver_sys : _solver_systems)
    solver_sys->compute(type);

  _aux->compute(type);
}

computeTransposeNullSpace()

void FEProblemBase::computeTransposeNullSpace ( libMesh::NonlinearImplicitSystem &  sys, std::vector< NumericVector< libMesh::Number > *> &  sp  )

virtualinherited

Definition at line 7866 of file FEProblemBase.C.

Referenced by Moose::compute_transpose_nullspace().

{
  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
              "I expect these system numbers to be the same");
  sp.clear();
  for (unsigned int i = 0; i < subspaceDim("TransposeNullSpace"); ++i)
  {
    std::stringstream postfix;
    postfix << "_" << i;
    sp.push_back(&_current_nl_sys->getVector("TransposeNullSpace" + postfix.str()));
  }
}

computeUserObjectByName()

void FEProblemBase::computeUserObjectByName ( const ExecFlagType &  type, const Moose::AuxGroup &  group, const std::string &  name  )

virtualinherited

Compute an user object with the given name.

Definition at line 4995 of file FEProblemBase.C.

Referenced by MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), MultiAppGeneralFieldUserObjectTransfer::execute(), MultiAppUserObjectTransfer::execute(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), and MultiAppConservativeTransfer::postExecute().

{
  const auto old_exec_flag = _current_execute_on_flag;
  _current_execute_on_flag = type;
  TheWarehouse::Query query = theWarehouse()
                                  .query()
                                  .condition<AttribSystem>("UserObject")
                                  .condition<AttribExecOns>(type)
                                  .condition<AttribName>(name);
  computeUserObjectsInternal(type, group, query);
  _current_execute_on_flag = old_exec_flag;
}

computeUserObjects()

void FEProblemBase::computeUserObjects ( const ExecFlagType &  type, const Moose::AuxGroup &  group  )

virtualinherited

Call compute methods on UserObjects.

Definition at line 5011 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::execute(), and FEProblemBase::initialSetup().

{
  TheWarehouse::Query query =
      theWarehouse().query().condition<AttribSystem>("UserObject").condition<AttribExecOns>(type);
  computeUserObjectsInternal(type, group, query);
}

computeUserObjectsInternal()

void FEProblemBase::computeUserObjectsInternal ( const ExecFlagType &  type, const Moose::AuxGroup &  group, TheWarehouse::Query &  query  )

protectedinherited

Definition at line 5019 of file FEProblemBase.C.

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

{
  try
  {
    TIME_SECTION("computeUserObjects", 1, "Computing User Objects");

    // Add group to query
    if (group == Moose::PRE_IC)
      primary_query.condition<AttribPreIC>(true);
    else if (group == Moose::PRE_AUX)
      primary_query.condition<AttribPreAux>(type);
    else if (group == Moose::POST_AUX)
      primary_query.condition<AttribPostAux>(type);

    // query everything first to obtain a list of execution groups
    std::vector<UserObject *> uos;
    primary_query.clone().queryIntoUnsorted(uos);
    std::set<int> execution_groups;
    for (const auto & uo : uos)
      execution_groups.insert(uo->getParam<int>("execution_order_group"));

    // iterate over execution order groups
    for (const auto execution_group : execution_groups)
    {
      auto query = primary_query.clone().condition<AttribExecutionOrderGroup>(execution_group);

      std::vector<GeneralUserObject *> genobjs;
      query.clone().condition<AttribInterfaces>(Interfaces::GeneralUserObject).queryInto(genobjs);

      std::vector<UserObject *> userobjs;
      query.clone()
          .condition<AttribInterfaces>(Interfaces::ElementUserObject | Interfaces::SideUserObject |
                                       Interfaces::InternalSideUserObject |
                                       Interfaces::InterfaceUserObject |
                                       Interfaces::DomainUserObject)
          .queryInto(userobjs);

      std::vector<UserObject *> tgobjs;
      query.clone()
          .condition<AttribInterfaces>(Interfaces::ThreadedGeneralUserObject)
          .queryInto(tgobjs);

      std::vector<UserObject *> nodal;
      query.clone().condition<AttribInterfaces>(Interfaces::NodalUserObject).queryInto(nodal);

      std::vector<MortarUserObject *> mortar;
      query.clone().condition<AttribInterfaces>(Interfaces::MortarUserObject).queryInto(mortar);

      if (userobjs.empty() && genobjs.empty() && tgobjs.empty() && nodal.empty() && mortar.empty())
        continue;

      // Start the timer here since we have at least one active user object
      std::string compute_uo_tag = "computeUserObjects(" + Moose::stringify(type) + ")";

      // Perform Residual/Jacobian setups
      if (type == EXEC_LINEAR)
      {
        for (auto obj : userobjs)
          obj->residualSetup();
        for (auto obj : nodal)
          obj->residualSetup();
        for (auto obj : mortar)
          obj->residualSetup();
        for (auto obj : tgobjs)
          obj->residualSetup();
        for (auto obj : genobjs)
          obj->residualSetup();
      }
      else if (type == EXEC_NONLINEAR)
      {
        for (auto obj : userobjs)
          obj->jacobianSetup();
        for (auto obj : nodal)
          obj->jacobianSetup();
        for (auto obj : mortar)
          obj->jacobianSetup();
        for (auto obj : tgobjs)
          obj->jacobianSetup();
        for (auto obj : genobjs)
          obj->jacobianSetup();
      }

      for (auto obj : userobjs)
        obj->initialize();

      // Execute Side/InternalSide/Interface/Elemental/DomainUserObjects
      if (!userobjs.empty())
      {
        // non-nodal user objects have to be run separately before the nodal user objects run
        // because some nodal user objects (NodalNormal related) depend on elemental user objects
        // :-(
        ComputeUserObjectsThread cppt(*this, query);
        Threads::parallel_reduce(*_mesh.getActiveLocalElementRange(), cppt);

        // There is one instance in rattlesnake where an elemental user object's finalize depends
        // on a side user object having been finalized first :-(
        joinAndFinalize(query.clone().condition<AttribInterfaces>(Interfaces::SideUserObject));
        joinAndFinalize(
            query.clone().condition<AttribInterfaces>(Interfaces::InternalSideUserObject));
        joinAndFinalize(query.clone().condition<AttribInterfaces>(Interfaces::InterfaceUserObject));
        joinAndFinalize(query.clone().condition<AttribInterfaces>(Interfaces::ElementUserObject));
        joinAndFinalize(query.clone().condition<AttribInterfaces>(Interfaces::DomainUserObject));
      }

      // if any userobject may have written to variables we need to close the aux solution
      for (const auto & uo : userobjs)
        if (auto euo = dynamic_cast<const ElementUserObject *>(uo);
            euo && euo->hasWritableCoupledVariables())
        {
          _aux->solution().close();
          _aux->system().update();
          break;
        }

      // Execute NodalUserObjects
      // BISON has an axial reloc elemental user object that has a finalize func that depends on a
      // nodal user object's prev value. So we can't initialize this until after elemental objects
      // have been finalized :-(
      for (auto obj : nodal)
        obj->initialize();
      if (query.clone().condition<AttribInterfaces>(Interfaces::NodalUserObject).count() > 0)
      {
        ComputeNodalUserObjectsThread cnppt(*this, query);
        Threads::parallel_reduce(*_mesh.getLocalNodeRange(), cnppt);
        joinAndFinalize(query.clone().condition<AttribInterfaces>(Interfaces::NodalUserObject));
      }

      // if any userobject may have written to variables we need to close the aux solution
      for (const auto & uo : nodal)
        if (auto nuo = dynamic_cast<const NodalUserObject *>(uo);
            nuo && nuo->hasWritableCoupledVariables())
        {
          _aux->solution().close();
          _aux->system().update();
          break;
        }

      // Execute MortarUserObjects
      {
        for (auto obj : mortar)
          obj->initialize();
        if (!mortar.empty())
        {
          auto create_and_run_mortar_functors = [this, type, &mortar](const bool displaced)
          {
            // go over mortar interfaces and construct functors
            const auto & mortar_interfaces = getMortarInterfaces(displaced);
            for (const auto & [primary_secondary_boundary_pair, mortar_generation_ptr] :
                 mortar_interfaces)
            {
              auto mortar_uos_to_execute =
                  getMortarUserObjects(primary_secondary_boundary_pair.first,
                                       primary_secondary_boundary_pair.second,
                                       displaced,
                                       mortar);

              auto * const subproblem = displaced
                                            ? static_cast<SubProblem *>(_displaced_problem.get())
                                            : static_cast<SubProblem *>(this);
              MortarUserObjectThread muot(mortar_uos_to_execute,
                                          *mortar_generation_ptr,
                                          *subproblem,
                                          *this,
                                          displaced,
                                          subproblem->assembly(0, 0));

              muot();
            }
          };

          create_and_run_mortar_functors(false);
          if (_displaced_problem)
            create_and_run_mortar_functors(true);
        }
        for (auto obj : mortar)
          obj->finalize();
      }

      // Execute threaded general user objects
      for (auto obj : tgobjs)
        obj->initialize();
      std::vector<GeneralUserObject *> tguos_zero;
      query.clone()
          .condition<AttribThread>(0)
          .condition<AttribInterfaces>(Interfaces::ThreadedGeneralUserObject)
          .queryInto(tguos_zero);
      for (auto obj : tguos_zero)
      {
        std::vector<GeneralUserObject *> tguos;
        auto q = query.clone()
                     .condition<AttribName>(obj->name())
                     .condition<AttribInterfaces>(Interfaces::ThreadedGeneralUserObject);
        q.queryInto(tguos);

        ComputeThreadedGeneralUserObjectsThread ctguot(*this);
        Threads::parallel_reduce(GeneralUserObjectRange(tguos.begin(), tguos.end()), ctguot);
        joinAndFinalize(q);
      }

      // Execute general user objects
      joinAndFinalize(query.clone().condition<AttribInterfaces>(Interfaces::GeneralUserObject),
                      true);
    }
  }
  catch (...)
  {
    handleException("computeUserObjectsInternal");
  }
}

computingNonlinearResid() [1/4]

bool SubProblem::computingNonlinearResid ( ) const

inlineinherited

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

Definition at line 707 of file SubProblem.h.

{ return _computing_nonlinear_residual; }

computingNonlinearResid() [2/4]

bool SubProblem::computingNonlinearResid

inlineinherited

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

Definition at line 707 of file SubProblem.h.

{ return _computing_nonlinear_residual; }

computingNonlinearResid() [3/4]

virtual void SubProblem::computingNonlinearResid

inlineinherited

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

Definition at line 712 of file SubProblem.h.

  {
    _computing_nonlinear_residual = computing_nonlinear_residual;
  }

computingNonlinearResid() [4/4]

void FEProblemBase::computingNonlinearResid ( bool  computing_nonlinear_residual )

finalvirtualinherited

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

Reimplemented from SubProblem.

Definition at line 9227 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeScaling(), ComputeResidualFunctor::residual(), ComputeFDResidualFunctor::residual(), and ComputeResidualAndJacobian::residual_and_jacobian().

{
  parallel_object_only();

  if (_displaced_problem)
    _displaced_problem->computingNonlinearResid(computing_nonlinear_residual);
  _computing_nonlinear_residual = computing_nonlinear_residual;
}

computingPreSMOResidual()

bool FEProblemBase::computingPreSMOResidual ( const unsigned int  nl_sys_num ) const

overridevirtualinherited

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.

Implements SubProblem.

Definition at line 6822 of file FEProblemBase.C.

Referenced by DisplacedProblem::computingPreSMOResidual().

{
  return _nl[nl_sys_num]->computingPreSMOResidual();
}

computingScalingJacobian() [1/2]

void FEProblemBase::computingScalingJacobian ( bool  computing_scaling_jacobian )

inlineinherited

Setter for whether we're computing the scaling jacobian.

Definition at line 2550 of file FEProblemBase.h.

Referenced by ComputeJacobianThread::compute(), SolverSystem::compute(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeScaling(), and DisplacedProblem::computingScalingJacobian().

  {
    _computing_scaling_jacobian = computing_scaling_jacobian;
  }

computingScalingJacobian() [2/2]

bool FEProblemBase::computingScalingJacobian ( ) const

inlinefinaloverridevirtualinherited

Getter for whether we're computing the scaling jacobian.

Implements SubProblem.

Definition at line 2555 of file FEProblemBase.h.

{ return _computing_scaling_jacobian; }

computingScalingResidual() [1/2]

void FEProblemBase::computingScalingResidual ( bool  computing_scaling_residual )

inlineinherited

Setter for whether we're computing the scaling residual.

Definition at line 2560 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeResidualTags(), NonlinearSystemBase::computeScaling(), and DisplacedProblem::computingScalingResidual().

  {
    _computing_scaling_residual = computing_scaling_residual;
  }

computingScalingResidual() [2/2]

bool FEProblemBase::computingScalingResidual ( ) const

inlinefinaloverridevirtualinherited

Returns

whether we are currently computing a residual for automatic scaling purposes

Implements SubProblem.

Definition at line 2568 of file FEProblemBase.h.

{ return _computing_scaling_residual; }

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.

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

{ return _console; }

constJacobian()

bool FEProblemBase::constJacobian ( ) const

inherited

Returns _const_jacobian (whether a MOOSE object has specified that the Jacobian is the same as the previous time it was computed)

Definition at line 9060 of file FEProblemBase.C.

Referenced by Moose::SlepcSupport::moosePetscSNESFormMatricesTags(), and Moose::SlepcSupport::moosePetscSNESFormMatrixTag().

{
  return _const_jacobian;
}

converged()

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

inlinevirtualinherited

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 113 of file SubProblem.h.

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

{ return solverSystemConverged(sys_num); }

coordTransform()

MooseAppCoordTransform & FEProblemBase::coordTransform ( )

inherited

Returns

the coordinate transformation object that describes how to transform this problem's coordinate system into the canonical/reference coordinate system

Definition at line 9463 of file FEProblemBase.C.

{
  return mesh().coordTransform();
}

copySolutionsBackwards()

void FEProblemBase::copySolutionsBackwards ( )

virtualinherited

Definition at line 6828 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

{
  TIME_SECTION("copySolutionsBackwards", 3, "Copying Solutions Backward");

  for (auto & sys : _solver_systems)
    sys->copySolutionsBackwards();
  _aux->copySolutionsBackwards();
}

coupling()

Moose::CouplingType FEProblemBase::coupling ( ) const

inlineinherited

Definition at line 177 of file FEProblemBase.h.

Referenced by DiffusionLHDGAssemblyHelper::checkCoupling(), and NonlinearSystemBase::computeJacobianInternal().

{ return _coupling; }

couplingEntries()

std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > & FEProblemBase::couplingEntries ( const THREAD_ID  tid, const unsigned int  nl_sys_num  )

inherited

Definition at line 6386 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeJacobianInternal(), ComputeFullJacobianThread::computeOnBoundary(), ComputeFullJacobianThread::computeOnElement(), ComputeFullJacobianThread::computeOnInterface(), ComputeFullJacobianThread::computeOnInternalFace(), Kernel::computeResidualAndJacobian(), NodalBC::computeResidualAndJacobian(), IntegratedBC::computeResidualAndJacobian(), ComputeNodalKernelBCJacobiansThread::onNode(), and ComputeNodalKernelJacobiansThread::onNode().

{
  return _assembly[tid][nl_sys]->couplingEntries();
}

couplingMatrix()

const libMesh::CouplingMatrix * FEProblemBase::couplingMatrix ( const unsigned int  nl_sys_num ) const

inlineoverridevirtualinherited

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

Implements SubProblem.

Definition at line 3525 of file FEProblemBase.h.

Referenced by DiffusionLHDGAssemblyHelper::checkCoupling(), DisplacedProblem::couplingMatrix(), and DisplacedProblem::init().

{
  return _cm[i].get();
}

createMortarInterface()

void FEProblemBase::createMortarInterface ( const std::pair< BoundaryID, BoundaryID > &  primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &  primary_secondary_subdomain_pair, bool  on_displaced, bool  periodic, const bool  debug, const bool  correct_edge_dropping, const Real  minimum_projection_angle  )

inherited

Definition at line 8041 of file FEProblemBase.C.

{
  _has_mortar = true;

  if (on_displaced)
    return _mortar_data->createMortarInterface(primary_secondary_boundary_pair,
                                               primary_secondary_subdomain_pair,
                                               *_displaced_problem,
                                               on_displaced,
                                               periodic,
                                               debug,
                                               correct_edge_dropping,
                                               minimum_projection_angle);
  else
    return _mortar_data->createMortarInterface(primary_secondary_boundary_pair,
                                               primary_secondary_subdomain_pair,
                                               *this,
                                               on_displaced,
                                               periodic,
                                               debug,
                                               correct_edge_dropping,
                                               minimum_projection_angle);
}

createQRules()

void FEProblemBase::createQRules ( libMesh::QuadratureType  type, libMesh::Order  order, libMesh::Order  volume_order = libMesh::INVALID_ORDER, libMesh::Order  face_order = libMesh::INVALID_ORDER, SubdomainID  block = Moose::ANY_BLOCK_ID, bool  allow_negative_qweights = true  )

virtualinherited

Definition at line 6248 of file FEProblemBase.C.

{
  if (order == INVALID_ORDER)
  {
    // automatically determine the integration order
    order = _solver_systems[0]->getMinQuadratureOrder();
    for (const auto i : make_range(std::size_t(1), _solver_systems.size()))
      if (order < _solver_systems[i]->getMinQuadratureOrder())
        order = _solver_systems[i]->getMinQuadratureOrder();
    if (order < _aux->getMinQuadratureOrder())
      order = _aux->getMinQuadratureOrder();
  }

  if (volume_order == INVALID_ORDER)
    volume_order = order;

  if (face_order == INVALID_ORDER)
    face_order = order;

  for (unsigned int tid = 0; tid < libMesh::n_threads(); ++tid)
    for (const auto i : index_range(_solver_systems))
      _assembly[tid][i]->createQRules(
          type, order, volume_order, face_order, block, allow_negative_qweights);

  if (_displaced_problem)
    _displaced_problem->createQRules(
        type, order, volume_order, face_order, block, allow_negative_qweights);

  updateMaxQps();
}

createTagMatrices()

void FEProblemBase::createTagMatrices ( CreateTaggedMatrixKey  )

inherited

Definition at line 696 of file FEProblemBase.C.

{
  auto & matrices = getParam<std::vector<std::vector<TagName>>>("extra_tag_matrices");
  for (const auto sys_num : index_range(matrices))
    for (auto & matrix : matrices[sys_num])
    {
      auto tag = addMatrixTag(matrix);
      _solver_systems[sys_num]->addMatrix(tag);
    }

  for (auto & sys : _solver_systems)
    sys->sizeVariableMatrixData();
  _aux->sizeVariableMatrixData();
}

createTagSolutions()

void FEProblemBase::createTagSolutions ( )

protectedinherited

Create extra tagged solution vectors.

Definition at line 712 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), ExternalProblem::ExternalProblem(), and FEProblem::FEProblem().

{
  for (auto & vector : getParam<std::vector<TagName>>("extra_tag_solutions"))
  {
    auto tag = addVectorTag(vector, Moose::VECTOR_TAG_SOLUTION);
    for (auto & sys : _solver_systems)
      sys->addVector(tag, false, libMesh::GHOSTED);
    _aux->addVector(tag, false, libMesh::GHOSTED);
  }

  if (_previous_nl_solution_required)
  {
    // We'll populate the zeroth state of the nonlinear iterations with the current solution for
    // ease of use in doing things like copying solutions backwards. We're just storing pointers in
    // the solution states containers so populating the zeroth state does not cost us the memory of
    // a new vector
    needSolutionState(1, Moose::SolutionIterationType::Nonlinear);
  }

  auto tag = addVectorTag(Moose::SOLUTION_TAG, Moose::VECTOR_TAG_SOLUTION);
  for (auto & sys : _solver_systems)
    sys->associateVectorToTag(*sys->system().current_local_solution.get(), tag);
  _aux->associateVectorToTag(*_aux->system().current_local_solution.get(), tag);
}

createTagVectors()

void FEProblemBase::createTagVectors ( )

protectedinherited

Create extra tagged vectors and matrices.

Definition at line 674 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), ExternalProblem::ExternalProblem(), and FEProblem::FEProblem().

{
  // add vectors and their tags to system
  auto & vectors = getParam<std::vector<std::vector<TagName>>>("extra_tag_vectors");
  for (const auto sys_num : index_range(vectors))
    for (auto & vector : vectors[sys_num])
    {
      auto tag = addVectorTag(vector);
      _solver_systems[sys_num]->addVector(tag, false, libMesh::GHOSTED);
    }

  auto & not_zeroed_vectors = getParam<std::vector<std::vector<TagName>>>("not_zeroed_tag_vectors");
  for (const auto sys_num : index_range(not_zeroed_vectors))
    for (auto & vector : not_zeroed_vectors[sys_num])
    {
      auto tag = addVectorTag(vector);
      _solver_systems[sys_num]->addVector(tag, false, GHOSTED);
      addNotZeroedVectorTag(tag);
    }
}

currentLinearSysNum()

unsigned int FEProblemBase::currentLinearSysNum ( ) const

overridevirtualinherited

Returns

the current linear system number

Implements SubProblem.

Definition at line 9480 of file FEProblemBase.C.

Referenced by DisplacedProblem::currentLinearSysNum().

{
  // If we don't have linear systems this should be an invalid number
  unsigned int current_linear_sys_num = libMesh::invalid_uint;
  if (_linear_systems.size())
    current_linear_sys_num = currentLinearSystem().number();

  return current_linear_sys_num;
}

currentLinearSystem() [1/2]

LinearSystem & FEProblemBase::currentLinearSystem ( )

inlineinherited

Get a non-constant reference to the current linear system.

Definition at line 3493 of file FEProblemBase.h.

Referenced by FEProblemBase::currentLinearSysNum(), and Moose::PetscSupport::petscLinearConverged().

{
  mooseAssert(_current_linear_sys, "The linear system is not currently set");
  return *_current_linear_sys;
}

currentLinearSystem() [2/2]

const LinearSystem & FEProblemBase::currentLinearSystem ( ) const

inlineinherited

Get a constant reference to the current linear system.

Definition at line 3500 of file FEProblemBase.h.

{
  mooseAssert(_current_linear_sys, "The linear system is not currently set");
  return *_current_linear_sys;
}

currentlyComputingJacobian()

const bool& SubProblem::currentlyComputingJacobian ( ) const

inlineinherited

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

Definition at line 684 of file SubProblem.h.

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

{ return _currently_computing_jacobian; };

currentlyComputingResidual() [1/2]

const bool& SubProblem::currentlyComputingResidual ( ) const

inlineinherited

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

Definition at line 720 of file SubProblem.h.

{ return _currently_computing_residual; }

currentlyComputingResidual() [2/2]

const bool& SubProblem::currentlyComputingResidual

inlineinherited

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

Definition at line 720 of file SubProblem.h.

{ return _currently_computing_residual; }

currentlyComputingResidualAndJacobian()

const bool & SubProblem::currentlyComputingResidualAndJacobian ( ) const

inlineinherited

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

Definition at line 1492 of file SubProblem.h.

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

{
  return _currently_computing_residual_and_jacobian;
}

currentNlSysNum()

unsigned int FEProblemBase::currentNlSysNum ( ) const

overridevirtualinherited

Returns

the current nonlinear system number

Implements SubProblem.

Definition at line 9469 of file FEProblemBase.C.

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

{
  // If we don't have nonlinear systems this should be an invalid number
  unsigned int current_nl_sys_num = libMesh::invalid_uint;
  if (_nl.size())
    current_nl_sys_num = currentNonlinearSystem().number();

  return current_nl_sys_num;
}

currentNonlinearSystem() [1/2]

NonlinearSystemBase & FEProblemBase::currentNonlinearSystem ( )

inlineinherited

Definition at line 3463 of file FEProblemBase.h.

Referenced by DefaultNonlinearConvergence::checkConvergence(), FEProblemBase::currentNlSysNum(), NonlinearSystemBase::jacobianSetup(), VariableResidualNormsDebugOutput::output(), Moose::PetscSupport::petscNonlinearConverged(), NonlinearSystemBase::residualSetup(), PetscOutput::solveSetup(), and ReferenceResidualConvergence::updateReferenceResidual().

{
  mooseAssert(_current_nl_sys, "The nonlinear system is not currently set");
  return *_current_nl_sys;
}

currentNonlinearSystem() [2/2]

const NonlinearSystemBase & FEProblemBase::currentNonlinearSystem ( ) const

inlineinherited

Definition at line 3470 of file FEProblemBase.h.

{
  mooseAssert(_current_nl_sys, "The nonlinear system is not currently set");
  return *_current_nl_sys;
}

currentResidualVectorTags()

const std::vector< VectorTag > & FEProblemBase::currentResidualVectorTags ( ) const

inlineoverridevirtualinherited

Return the residual vector tags we are currently computing.

Implements SubProblem.

Definition at line 3541 of file FEProblemBase.h.

Referenced by FEProblemBase::addResidual(), FEProblemBase::addResidualLower(), FEProblemBase::addResidualNeighbor(), FEProblemBase::addResidualScalar(), and DisplacedProblem::currentResidualVectorTags().

{
  return _current_residual_vector_tags;
}

customSetup()

void FEProblemBase::customSetup ( const ExecFlagType &  exec_type )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 4795 of file FEProblemBase.C.

Referenced by FEProblemBase::execute().

{
  SubProblem::customSetup(exec_type);

  if (_line_search)
    _line_search->customSetup(exec_type);

  unsigned int n_threads = libMesh::n_threads();
  for (THREAD_ID tid = 0; tid < n_threads; tid++)
  {
    _all_materials.customSetup(exec_type, tid);
    _functions.customSetup(exec_type, tid);
  }

  _aux->customSetup(exec_type);
  for (auto & nl : _nl)
    nl->customSetup(exec_type);

  if (_displaced_problem)
    _displaced_problem->customSetup(exec_type);

  for (THREAD_ID tid = 0; tid < n_threads; tid++)
  {
    _internal_side_indicators.customSetup(exec_type, tid);
    _indicators.customSetup(exec_type, tid);
    _markers.customSetup(exec_type, tid);
  }

  std::vector<UserObject *> userobjs;
  theWarehouse().query().condition<AttribSystem>("UserObject").queryIntoUnsorted(userobjs);
  for (auto obj : userobjs)
    obj->customSetup(exec_type);

  _app.getOutputWarehouse().customSetup(exec_type);
}

declareManagedRestartableDataWithContext()

template<typename T , typename... Args>

Restartable::ManagedValue< T > Restartable::declareManagedRestartableDataWithContext ( const std::string &  data_name, void *  context, Args &&...  args  )

protectedinherited

Declares a piece of "managed" restartable data and initialize it.

Here, "managed" restartable data means that the caller can destruct this data upon destruction of the return value of this method. Therefore, this ManagedValue<T> wrapper should survive after the final calls to dataStore() for it. That is... at the very end.

This is needed for objects whose destruction ordering is important, and enables natural c++ destruction in reverse construction order of the object that declares it.

See delcareRestartableData and declareRestartableDataWithContext for more information.

Definition at line 283 of file Restartable.h.

{
  auto & data_ptr =
      declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...);
  return Restartable::ManagedValue<T>(data_ptr);
}

declareRecoverableData()

template<typename T , typename... Args>

T & Restartable::declareRecoverableData ( const std::string &  data_name, Args &&...  args  )

protectedinherited

Declare a piece of data as "recoverable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
args	Arguments to forward to the constructor of the data

Definition at line 358 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);

  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);

  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableData()

template<typename T , typename... Args>

T & Restartable::declareRestartableData ( const std::string &  data_name, Args &&...  args  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
args	Arguments to forward to the constructor of the data

Definition at line 276 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableDataWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithContext ( const std::string &  data_name, void *  context, Args &&...  args  )

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 301 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...).set();
}

declareRestartableDataWithObjectName()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectName ( const std::string &  data_name, const std::string &  object_name, Args &&...  args  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
args	Arguments to forward to the constructor of the data

Definition at line 330 of file Restartable.h.

{
  return declareRestartableDataWithObjectNameWithContext<T>(
      data_name, object_name, nullptr, std::forward<Args>(args)...);
}

declareRestartableDataWithObjectNameWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectNameWithContext ( const std::string &  data_name, const std::string &  object_name, void *  context, Args &&...  args  )

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 340 of file Restartable.h.

{
  std::string old_name = _restartable_name;

  _restartable_name = object_name;

  T & value = declareRestartableDataWithContext<T>(data_name, context, std::forward<Args>(args)...);

  _restartable_name = old_name;

  return value;
}

defaultGhosting()

bool SubProblem::defaultGhosting ( )

inlineinherited

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

Definition at line 144 of file SubProblem.h.

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

{ return _default_ghosting; }

diracKernelInfo()

DiracKernelInfo & SubProblem::diracKernelInfo ( )

virtualinherited

Definition at line 749 of file SubProblem.C.

{
  return _dirac_kernel_info;
}

displaceMesh()

void MFEMProblem::displaceMesh

(

)

Displace the mesh, if mesh displacement is enabled.

Definition at line 434 of file MFEMProblem.C.

Referenced by MFEMProblemSolve::solve().

{
  // Displace mesh
  if (mesh().shouldDisplace())
  {
    mesh().displace(static_cast<mfem::GridFunction const &>(*getMeshDisplacementGridFunction()));
    // TODO: update FESpaces GridFunctions etc for transient solves
  }
}

doingPRefinement()

bool SubProblem::doingPRefinement ( ) const

inherited

Returns

whether we're doing p-refinement

Definition at line 1366 of file SubProblem.C.

Referenced by FEProblemBase::meshChanged().

{
  return mesh().doingPRefinement();
}

dt()

virtual Real& FEProblemBase::dt ( ) const

inlinevirtualinherited

Definition at line 544 of file FEProblemBase.h.

Referenced by DefaultSteadyStateConvergence::checkConvergence(), SolverSystem::compute(), AuxiliarySystem::compute(), EigenExecutionerBase::EigenExecutionerBase(), TimestepSize::getValue(), PseudoTimestep::outputPseudoTimestep(), FixedPointSolve::solve(), Moose::MFEM::TimeDomainEquationSystemProblemOperator::Solve(), and WebServerControl::startServer().

{ return _dt; }

dtOld()

virtual Real& FEProblemBase::dtOld ( ) const

inlinevirtualinherited

Definition at line 545 of file FEProblemBase.h.

Referenced by IterationAdaptiveDT::acceptStep().

{ return _dt_old; }

duplicateVariableCheck()

bool FEProblemBase::duplicateVariableCheck ( const std::string &  var_name, const libMesh::FEType &  type, bool  is_aux, const std::set< SubdomainID > *const  active_subdomains  )

protectedinherited

Helper to check for duplicate variable names across systems or within a single system.

Definition at line 2785 of file FEProblemBase.C.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), and FEProblemBase::addVariable().

{
  std::set<SubdomainID> subdomainIDs;
  if (active_subdomains->size() == 0)
  {
    const auto subdomains = _mesh.meshSubdomains();
    subdomainIDs.insert(subdomains.begin(), subdomains.end());
  }
  else
    subdomainIDs.insert(active_subdomains->begin(), active_subdomains->end());

  for (auto & sys : _solver_systems)
  {
    SystemBase * curr_sys_ptr = sys.get();
    SystemBase * other_sys_ptr = _aux.get();
    std::string error_prefix = "";
    if (is_aux)
    {
      curr_sys_ptr = _aux.get();
      other_sys_ptr = sys.get();
      error_prefix = "aux";
    }

    if (other_sys_ptr->hasVariable(var_name))
      mooseError("Cannot have an auxiliary variable and a solver variable with the same name: ",
                 var_name);

    if (curr_sys_ptr->hasVariable(var_name))
    {
      const Variable & var =
          curr_sys_ptr->system().variable(curr_sys_ptr->system().variable_number(var_name));

      // variable type
      if (var.type() != type)
      {
        const auto stringifyType = [](FEType t)
        { return Moose::stringify(t.family) + " of order " + Moose::stringify(t.order); };

        mooseError("Mismatching types are specified for ",
                   error_prefix,
                   "variable with name '",
                   var_name,
                   "': '",
                   stringifyType(var.type()),
                   "' and '",
                   stringifyType(type),
                   "'");
      }

      // block-restriction
      if (!(active_subdomains->size() == 0 && var.active_subdomains().size() == 0))
      {
        const auto varActiveSubdomains = var.active_subdomains();
        std::set<SubdomainID> varSubdomainIDs;
        if (varActiveSubdomains.size() == 0)
        {
          const auto subdomains = _mesh.meshSubdomains();
          varSubdomainIDs.insert(subdomains.begin(), subdomains.end());
        }
        else
          varSubdomainIDs.insert(varActiveSubdomains.begin(), varActiveSubdomains.end());

        // Is subdomainIDs a subset of varSubdomainIDs? With this we allow the case that the newly
        // requested block restriction is only a subset of the existing one.
        const auto isSubset = std::includes(varSubdomainIDs.begin(),
                                            varSubdomainIDs.end(),
                                            subdomainIDs.begin(),
                                            subdomainIDs.end());

        if (!isSubset)
        {
          // helper function: make a string from a set of subdomain ids
          const auto stringifySubdomains = [this](std::set<SubdomainID> subdomainIDs)
          {
            std::stringstream s;
            for (auto const i : subdomainIDs)
            {
              // do we need to insert a comma?
              if (s.tellp() != 0)
                s << ", ";

              // insert subdomain name and id -or- only the id (if no name is given)
              const auto subdomainName = _mesh.getSubdomainName(i);
              if (subdomainName.empty())
                s << i;
              else
                s << subdomainName << " (" << i << ")";
            }
            return s.str();
          };

          const std::string msg = "Mismatching block-restrictions are specified for " +
                                  error_prefix + "variable with name '" + var_name + "': {" +
                                  stringifySubdomains(varSubdomainIDs) + "} and {" +
                                  stringifySubdomains(subdomainIDs) + "}";

          mooseError(msg);
        }
      }

      return true;
    }
  }

  return false;
}

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.

Referenced by EigenKernel::enabled().

{ return _enabled; }

errorOnJacobianNonzeroReallocation()

bool FEProblemBase::errorOnJacobianNonzeroReallocation ( ) const

inlineinherited

Will return True if the user wants to get an error when a nonzero is reallocated in the Jacobian by PETSc.

Definition at line 2151 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), and NonlinearSystemBase::constraintJacobians().

  {
    return _error_on_jacobian_nonzero_reallocation;
  }

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& FEProblemBase::es ( )

inlineoverridevirtualinherited

Implements SubProblem.

Definition at line 162 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptMesh(), PhysicsBasedPreconditioner::addSystem(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), DefaultNonlinearConvergence::DefaultNonlinearConvergence(), EigenProblem::EigenProblem(), MultiAppProjectionTransfer::execute(), FEProblem::FEProblem(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), MultiAppFieldTransfer::getEquationSystem(), FEProblemBase::getEvaluableElementRange(), Adaptivity::init(), FEProblemBase::init(), MultiAppProjectionTransfer::initialSetup(), SampledOutput::initSample(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::meshChanged(), EigenExecutionerBase::nonlinearSolve(), DOFMapOutput::output(), Output::Output(), Moose::PetscSupport::petscSetKSPDefaults(), MultiAppProjectionTransfer::projectSolution(), FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects(), Moose::SlepcSupport::setEigenProblemSolverParams(), ExplicitTimeIntegrator::solveLinearSystem(), FEProblemBase::timestepSetup(), and SampledOutput::updateSample().

{ return _req.set().es(); }

execMultiApps()

bool FEProblemBase::execMultiApps ( ExecFlagType  type, bool  auto_advance = true  )

inherited

Execute the MultiApps associated with the ExecFlagType.

Definition at line 5638 of file FEProblemBase.C.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), MFEMSteady::execute(), TransientBase::execute(), SteadyBase::execute(), Eigenvalue::execute(), FEProblemBase::initialSetup(), EigenExecutionerBase::postExecute(), MFEMProblemSolve::solve(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

{
  // Active MultiApps
  const std::vector<MooseSharedPointer<MultiApp>> & multi_apps =
      _multi_apps[type].getActiveObjects();

  // Do anything that needs to be done to Apps before transfers
  for (const auto & multi_app : multi_apps)
    multi_app->preTransfer(_dt, _time);

  // Execute Transfers _to_ MultiApps
  execMultiAppTransfers(type, MultiAppTransfer::TO_MULTIAPP);

  // Execute Transfers _between_ Multiapps
  execMultiAppTransfers(type, MultiAppTransfer::BETWEEN_MULTIAPP);

  // Execute MultiApps
  if (multi_apps.size())
  {
    TIME_SECTION("execMultiApps", 1, "Executing MultiApps", false);

    if (_verbose_multiapps)
      _console << COLOR_CYAN << "\nExecuting MultiApps on " << Moose::stringify(type)
               << COLOR_DEFAULT << std::endl;

    bool success = true;

    for (const auto & multi_app : multi_apps)
    {
      success = multi_app->solveStep(_dt, _time, auto_advance);
      // no need to finish executing the subapps if one fails
      if (!success)
        break;
    }

    MooseUtils::parallelBarrierNotify(_communicator, _parallel_barrier_messaging);

    _communicator.min(success);

    if (!success)
      return false;

    if (_verbose_multiapps)
      _console << COLOR_CYAN << "Finished Executing MultiApps on " << Moose::stringify(type) << "\n"
               << COLOR_DEFAULT << std::endl;
  }

  // Execute Transfers _from_ MultiApps
  execMultiAppTransfers(type, MultiAppTransfer::FROM_MULTIAPP);

  // If we made it here then everything passed
  return true;
}

execMultiAppTransfers()

void FEProblemBase::execMultiAppTransfers ( ExecFlagType  type, Transfer::DIRECTION  direction  )

inherited

Execute MultiAppTransfers associated with execution flag and direction.

Parameters

type	The execution flag to execute.
direction	The direction (to or from) to transfer.

Definition at line 5538 of file FEProblemBase.C.

Referenced by FEProblemBase::execMultiApps().

{
  bool to_multiapp = direction == MultiAppTransfer::TO_MULTIAPP;
  bool from_multiapp = direction == MultiAppTransfer::FROM_MULTIAPP;
  std::string string_direction;
  if (to_multiapp)
    string_direction = " To ";
  else if (from_multiapp)
    string_direction = " From ";
  else
    string_direction = " Between ";

  const MooseObjectWarehouse<Transfer> & wh = to_multiapp     ? _to_multi_app_transfers[type]
                                              : from_multiapp ? _from_multi_app_transfers[type]
                                                              : _between_multi_app_transfers[type];

  if (wh.hasActiveObjects())
  {
    TIME_SECTION("execMultiAppTransfers", 1, "Executing Transfers");

    const auto & transfers = wh.getActiveObjects();

    if (_verbose_multiapps)
    {
      _console << COLOR_CYAN << "\nTransfers on " << Moose::stringify(type) << string_direction
               << "MultiApps" << COLOR_DEFAULT << ":" << std::endl;

      VariadicTable<std::string, std::string, std::string, std::string> table(
          {"Name", "Type", "From", "To"});

      // Build Table of Transfer Info
      for (const auto & transfer : transfers)
      {
        auto multiapp_transfer = dynamic_cast<MultiAppTransfer *>(transfer.get());

        table.addRow(multiapp_transfer->name(),
                     multiapp_transfer->type(),
                     multiapp_transfer->getFromName(),
                     multiapp_transfer->getToName());
      }

      // Print it
      table.print(_console);
    }

    for (const auto & transfer : transfers)
    {
      transfer->setCurrentDirection(direction);
      transfer->execute();
    }

    MooseUtils::parallelBarrierNotify(_communicator, _parallel_barrier_messaging);

    if (_verbose_multiapps)
      _console << COLOR_CYAN << "Transfers on " << Moose::stringify(type) << " Are Finished\n"
               << COLOR_DEFAULT << std::endl;
  }
  else if (_multi_apps[type].getActiveObjects().size())
  {
    if (_verbose_multiapps)
      _console << COLOR_CYAN << "\nNo Transfers on " << Moose::stringify(type) << string_direction
               << "MultiApps\n"
               << COLOR_DEFAULT << std::endl;
  }
}

execTransfers()

void FEProblemBase::execTransfers ( ExecFlagType  type )

inherited

Execute the Transfers associated with the ExecFlagType.

Note: This does not execute MultiApp Transfers! Those are executed automatically when MultiApps are executed.

Definition at line 5808 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::initialSetup(), FixedPointSolve::solve(), MFEMProblemSolve::solve(), and FixedPointSolve::solveStep().

{
  if (_transfers[type].hasActiveObjects())
  {
    TIME_SECTION("execTransfers", 3, "Executing Transfers");

    const auto & transfers = _transfers[type].getActiveObjects();

    for (const auto & transfer : transfers)
      transfer->execute();
  }
}

execute()

void FEProblemBase::execute ( const ExecFlagType &  exec_type )

virtualinherited

Convenience function for performing execution of MOOSE systems.

Reimplemented in EigenProblem, and DumpObjectsProblem.

Definition at line 4832 of file FEProblemBase.C.

Referenced by EigenExecutionerBase::chebyshev(), FixedPointSolve::examineFixedPointConvergence(), MFEMSteady::execute(), SteadyBase::execute(), TransientBase::execute(), EigenProblem::execute(), NonlinearEigen::init(), MFEMSteady::init(), Steady::init(), EigenExecutionerBase::init(), TransientBase::init(), FEProblemBase::initialSetup(), EigenExecutionerBase::makeBXConsistent(), EigenExecutionerBase::normalizeSolution(), Moose::PetscSupport::petscLinearConverged(), Moose::PetscSupport::petscNonlinearConverged(), EigenExecutionerBase::postExecute(), FixedPointSolve::solve(), MFEMProblemSolve::solve(), FixedPointSolve::solveStep(), InversePowerMethod::takeStep(), and NonlinearEigen::takeStep().

{
  // Set the current flag
  setCurrentExecuteOnFlag(exec_type);

  if (exec_type != EXEC_INITIAL)
    executeControls(exec_type);

  // intentially call this after executing controls because the setups may rely on the controls
  // FIXME: we skip the following flags because they have dedicated setup functions in
  //        SetupInterface and it may not be appropriate to call them here.
  if (!(exec_type == EXEC_INITIAL || exec_type == EXEC_TIMESTEP_BEGIN ||
        exec_type == EXEC_SUBDOMAIN || exec_type == EXEC_NONLINEAR || exec_type == EXEC_LINEAR))
    customSetup(exec_type);

  // Samplers; EXEC_INITIAL is not called because the Sampler::init() method that is called after
  // construction makes the first Sampler::execute() call. This ensures that the random number
  // generator object is the correct state prior to any other object (e.g., Transfers) attempts to
  // extract data from the Sampler. That is, if the Sampler::execute() call is delayed to here
  // then it is not in the correct state for other objects.
  if (exec_type != EXEC_INITIAL)
    executeSamplers(exec_type);

  // Pre-aux UserObjects
  computeUserObjects(exec_type, Moose::PRE_AUX);

  // Systems (includes system time derivative and aux kernel calculations)
  computeSystems(exec_type);
  // With the auxiliary system solution computed, sync the displaced problem auxiliary solution
  // before computation of post-aux user objects. The undisplaced auxiliary system current local
  // solution is updated (via System::update) within the AuxiliarySystem class's variable
  // computation methods (e.g. computeElementalVarsHelper, computeNodalVarsHelper), so it is safe to
  // use it here
  if (_displaced_problem)
    _displaced_problem->syncAuxSolution(*getAuxiliarySystem().currentSolution());

  // Post-aux UserObjects
  computeUserObjects(exec_type, Moose::POST_AUX);

  // Return the current flag to None
  setCurrentExecuteOnFlag(EXEC_NONE);

  if (_uo_aux_state_check && !_checking_uo_aux_state)
  {
    // we will only check aux variables and postprocessors
    // checking more reporter data can be added in the future if needed
    std::unique_ptr<NumericVector<Number>> x = _aux->currentSolution()->clone();
    DenseVector<Real> pp_values = getReporterData().getAllRealReporterValues();

    // call THIS execute one more time for checking the possible states
    _checking_uo_aux_state = true;
    FEProblemBase::execute(exec_type);
    _checking_uo_aux_state = false;

    const Real check_tol = 1e-8;

    const Real xnorm = x->l2_norm();
    *x -= *_aux->currentSolution();
    if (x->l2_norm() > check_tol * xnorm)
    {
      const auto & sys = _aux->system();
      const unsigned int n_vars = sys.n_vars();
      std::multimap<Real, std::string, std::greater<Real>> ordered_map;
      for (const auto i : make_range(n_vars))
      {
        const Real vnorm = sys.calculate_norm(*x, i, DISCRETE_L2);
        ordered_map.emplace(vnorm, sys.variable_name(i));
      }

      std::ostringstream oss;
      for (const auto & [error_norm, var_name] : ordered_map)
        oss << "  {" << var_name << ", " << error_norm << "},\n";

      mooseError("Aux kernels, user objects appear to have states for aux variables on ",
                 exec_type,
                 ".\nVariable error norms in descending order:\n",
                 oss.str());
    }

    const DenseVector<Real> new_pp_values = getReporterData().getAllRealReporterValues();
    if (pp_values.size() != new_pp_values.size())
      mooseError("Second execution for uo/aux state check should not change the number of "
                 "real reporter values");

    const Real ppnorm = pp_values.l2_norm();
    pp_values -= new_pp_values;
    if (pp_values.l2_norm() > check_tol * ppnorm)
    {
      const auto pp_names = getReporterData().getAllRealReporterFullNames();
      std::multimap<Real, std::string, std::greater<Real>> ordered_map;
      for (const auto i : index_range(pp_names))
        ordered_map.emplace(std::abs(pp_values(i)), pp_names[i]);

      std::ostringstream oss;
      for (const auto & [error_norm, pp_name] : ordered_map)
        oss << "  {" << pp_name << ", " << error_norm << "},\n";

      mooseError("Aux kernels, user objects appear to have states for real reporter values on ",
                 exec_type,
                 ".\nErrors of real reporter values in descending order:\n",
                 oss.str());
    }
  }
}

executeAllObjects()

void FEProblemBase::executeAllObjects ( const ExecFlagType &  exec_type )

virtualinherited

Definition at line 4790 of file FEProblemBase.C.

Referenced by Executor::exec().

{
}

executeControls()

void FEProblemBase::executeControls ( const ExecFlagType &  exec_type )

inherited

Performs setup and execute calls for Control objects.

Definition at line 5232 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::execute(), and FEProblemBase::initialSetup().

{
  if (_control_warehouse[exec_type].hasActiveObjects())
  {
    TIME_SECTION("executeControls", 1, "Executing Controls");

    DependencyResolver<std::shared_ptr<Control>> resolver;

    auto controls_wh = _control_warehouse[exec_type];
    // Add all of the dependencies into the resolver and sort them
    for (const auto & it : controls_wh.getActiveObjects())
    {
      // Make sure an item with no dependencies comes out too!
      resolver.addItem(it);

      std::vector<std::string> & dependent_controls = it->getDependencies();
      for (const auto & depend_name : dependent_controls)
      {
        if (controls_wh.hasActiveObject(depend_name))
        {
          auto dep_control = controls_wh.getActiveObject(depend_name);
          resolver.addEdge(dep_control, it);
        }
        else
          mooseError("The Control \"",
                     depend_name,
                     "\" was not created, did you make a "
                     "spelling mistake or forget to include it "
                     "in your input file?");
      }
    }

    const auto & ordered_controls = resolver.getSortedValues();

    if (!ordered_controls.empty())
    {
      _control_warehouse.setup(exec_type);
      // Run the controls in the proper order
      for (const auto & control : ordered_controls)
        control->execute();
    }
  }
}

executeSamplers()

void FEProblemBase::executeSamplers ( const ExecFlagType &  exec_type )

inherited

Performs setup and execute calls for Sampler objects.

Definition at line 5277 of file FEProblemBase.C.

Referenced by FEProblemBase::execute().

{
  // TODO: This should be done in a threaded loop, but this should be super quick so for now
  // do a serial loop.
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
  {
    std::vector<Sampler *> objects;
    theWarehouse()
        .query()
        .condition<AttribSystem>("Sampler")
        .condition<AttribThread>(tid)
        .condition<AttribExecOns>(exec_type)
        .queryInto(objects);

    if (!objects.empty())
    {
      TIME_SECTION("executeSamplers", 1, "Executing Samplers");
      FEProblemBase::objectSetupHelper<Sampler>(objects, exec_type);
      FEProblemBase::objectExecuteHelper<Sampler>(objects);
    }
  }
}

externalSolve()

virtual void MFEMProblem::externalSolve ( )

inlineoverridevirtual

New interface for solving an External problem.

"solve()" is finalized here to provide callbacks for solution syncing.

Implements ExternalProblem.

Definition at line 26 of file MFEMProblem.h.

{}

feBackend()

Moose::FEBackend MFEMProblem::feBackend ( ) const

inlineoverridevirtual

Reimplemented from FEProblemBase.

Definition at line 204 of file MFEMProblem.h.

{ return Moose::FEBackend::MFEM; }

finalizeMultiApps()

void FEProblemBase::finalizeMultiApps ( )

inherited

Definition at line 5693 of file FEProblemBase.C.

Referenced by MFEMSteady::execute(), SteadyBase::execute(), TransientBase::execute(), and Eigenvalue::execute().

{
  const auto & multi_apps = _multi_apps.getActiveObjects();

  for (const auto & multi_app : multi_apps)
    multi_app->finalize();
}

finalNonlinearResidual()

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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6816 of file FEProblemBase.C.

{
  return _nl[nl_sys_num]->finalNonlinearResidual();
}

finishMultiAppStep()

void FEProblemBase::finishMultiAppStep ( ExecFlagType  type, bool  recurse_through_multiapp_levels = false  )

inherited

Finish the MultiApp time step (endStep, postStep) associated with the ExecFlagType.

Optionally recurse through all multi-app levels

Definition at line 5721 of file FEProblemBase.C.

Referenced by FEProblemBase::advanceMultiApps(), TransientBase::execute(), TransientMultiApp::finishStep(), and TransientBase::incrementStepOrReject().

{
  const auto & multi_apps = _multi_apps[type].getActiveObjects();

  if (multi_apps.size())
  {
    if (_verbose_multiapps)
      _console << COLOR_CYAN << "\nAdvancing MultiApps on " << type.name() << COLOR_DEFAULT
               << std::endl;

    for (const auto & multi_app : multi_apps)
      multi_app->finishStep(recurse_through_multiapp_levels);

    MooseUtils::parallelBarrierNotify(_communicator, _parallel_barrier_messaging);

    if (_verbose_multiapps)
      _console << COLOR_CYAN << "Finished Advancing MultiApps on " << type.name() << "\n"
               << COLOR_DEFAULT << std::endl;
  }
}

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

forceOutput()

void FEProblemBase::forceOutput ( )

inherited

Indicates that the next call to outputStep should be forced.

This is needed by the MultiApp system, if forceOutput is called the next call to outputStep, regardless of the type supplied to the call, will be executed with EXEC_FORCED.

Forced output will NOT override the allowOutput flag.

Definition at line 6951 of file FEProblemBase.C.

Referenced by TransientMultiApp::solveStep().

{
  _app.getOutputWarehouse().forceOutput();
}

fvBCsIntegrityCheck() [1/2]

bool FEProblemBase::fvBCsIntegrityCheck ( ) const

inlineinherited

Returns

whether to perform a boundary condition integrity check for finite volume

Definition at line 2479 of file FEProblemBase.h.

{ return _fv_bcs_integrity_check; }

fvBCsIntegrityCheck() [2/2]

void FEProblemBase::fvBCsIntegrityCheck ( bool  fv_bcs_integrity_check )

inlineinherited

Parameters

fv_bcs_integrity_check

Whether to perform a boundary condition integrity check for finite volume

Definition at line 3531 of file FEProblemBase.h.

{
  if (!_fv_bcs_integrity_check)
    // the user has requested that we don't check integrity so we will honor that
    return;

  _fv_bcs_integrity_check = fv_bcs_integrity_check;
}

geomSearchData()

virtual GeometricSearchData& FEProblemBase::geomSearchData ( )

inlineoverridevirtualinherited

Implements SubProblem.

Definition at line 1827 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::augmentSparsity(), NonlinearSystemBase::computeJacobianInternal(), DMMooseGetEmbedding_Private(), and DMSetUp_Moose_Pre().

{ return _geometric_search_data; }

getActiveElementalMooseVariables()

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

virtualinherited

Get the MOOSE variables to be reinited on each element.

Parameters

tid	The thread id

Definition at line 455 of file SubProblem.C.

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

{
  return _active_elemental_moose_variables[tid];
}

getActiveFEVariableCoupleableMatrixTags()

const std::set< TagID > & SubProblem::getActiveFEVariableCoupleableMatrixTags ( const THREAD_ID  tid ) const

inherited

Definition at line 391 of file SubProblem.C.

{
  return _active_fe_var_coupleable_matrix_tags[tid];
}

getActiveFEVariableCoupleableVectorTags()

const std::set< TagID > & SubProblem::getActiveFEVariableCoupleableVectorTags ( const THREAD_ID  tid ) const

inherited

Definition at line 397 of file SubProblem.C.

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute().

{
  return _active_fe_var_coupleable_vector_tags[tid];
}

getActiveScalarVariableCoupleableMatrixTags()

const std::set< TagID > & SubProblem::getActiveScalarVariableCoupleableMatrixTags ( const THREAD_ID  tid ) const

inherited

Definition at line 432 of file SubProblem.C.

Referenced by MooseVariableScalar::reinit().

{
  return _active_sc_var_coupleable_matrix_tags[tid];
}

getActiveScalarVariableCoupleableVectorTags()

const std::set< TagID > & SubProblem::getActiveScalarVariableCoupleableVectorTags ( const THREAD_ID  tid ) const

inherited

Definition at line 438 of file SubProblem.C.

{
  return _active_sc_var_coupleable_vector_tags[tid];
}

getActualFieldVariable()

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

overridevirtualinherited

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

Implements SubProblem.

Definition at line 5938 of file FEProblemBase.C.

Referenced by MultiAppVariableValueSampleTransfer::execute().

{
  for (auto & sys : _solver_systems)
    if (sys->hasVariable(var_name))
      return sys->getActualFieldVariable<Real>(tid, var_name);
  if (_aux->hasVariable(var_name))
    return _aux->getActualFieldVariable<Real>(tid, var_name);

  mooseError("Unknown variable " + var_name);
}

getArrayVariable()

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

overridevirtualinherited

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

Implements SubProblem.

Definition at line 5962 of file FEProblemBase.C.

Referenced by CoupleableMooseVariableDependencyIntermediateInterface::coupledArrayValueByName(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), and PointwiseRenormalizeVector::PointwiseRenormalizeVector().

{
  for (auto & sys : _solver_systems)
    if (sys->hasVariable(var_name))
      return sys->getFieldVariable<RealEigenVector>(tid, var_name);
  if (_aux->hasVariable(var_name))
    return _aux->getFieldVariable<RealEigenVector>(tid, var_name);

  mooseError("Unknown variable " + var_name);
}

getAuxiliarySystem()

AuxiliarySystem& FEProblemBase::getAuxiliarySystem ( )

inlineinherited

Definition at line 956 of file FEProblemBase.h.

Referenced by Adaptivity::adaptMesh(), DisplacedProblem::addTimeIntegrator(), ElementSubdomainModifierBase::applyIC(), TransientMultiApp::appTransferVector(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), PNGOutput::calculateRescalingValues(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCs(), NonlinearSystemBase::computeResidualTags(), NonlinearSystemBase::constraintResiduals(), DisplacedProblem::DisplacedProblem(), EigenExecutionerBase::EigenExecutionerBase(), FEProblemBase::execute(), ReferenceResidualConvergence::initialSetup(), FEProblemBase::initialSetup(), ActivateElementsUserObjectBase::initSolutions(), EigenExecutionerBase::inversePowerIteration(), PNGOutput::makeMeshFunc(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), ConsoleUtils::outputAuxiliarySystemInformation(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), MultiApp::restore(), NonlinearSystemBase::setConstraintSecondaryValues(), TransientMultiApp::setupApp(), TransientMultiApp::solveStep(), AB2PredictorCorrector::step(), DisplacedProblem::syncSolutions(), ReferenceResidualConvergence::updateReferenceResidual(), and Coupleable::writableCoupledValue().

{ return *_aux; }

getAuxVariableNames()

std::vector< VariableName > MFEMProblem::getAuxVariableNames ( )

virtual

Returns all the variable names from the auxiliary system base.

This is helpful in the syncSolutions() method when transferring variable data.

Definition at line 460 of file MFEMProblem.C.

{
  return systemBaseAuxiliary().getVariableNames();
}

getAxisymmetricRadialCoord()

unsigned int SubProblem::getAxisymmetricRadialCoord ( ) const

inherited

Returns the desired radial direction for RZ coordinate transformation.

Returns

The coordinate direction for the radial direction

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

Referenced by Factory::copyConstruct(), and MooseBase::uniqueParameterName().

{ return _pars.getBase(); }

getBndMaterialPropertyStorage()

const MaterialPropertyStorage& FEProblemBase::getBndMaterialPropertyStorage ( )

inlineinherited

Definition at line 1849 of file FEProblemBase.h.

{ return _bnd_material_props; }

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 432 of file MooseBase.h.

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

getCoefficients()

Moose::MFEM::CoefficientManager& MFEMProblem::getCoefficients ( )

inline

Method to get the PropertyManager object for storing material properties and converting them to MFEM coefficients.

This is used by Material and Kernel classes (among others).

Definition at line 180 of file MFEMProblem.h.

Referenced by addFunction(), addGridFunction(), addPostprocessor(), MFEMGeneralUserObject::getMatrixCoefficientByName(), MFEMGeneralUserObject::getScalarCoefficientByName(), and MFEMGeneralUserObject::getVectorCoefficientByName().

{ return _problem_data.coefficients; }

getComm()

MPI_Comm MFEMProblem::getComm ( )

inline

Return the MPI communicator associated with this FE problem's mesh.

Definition at line 191 of file MFEMProblem.h.

Referenced by addMFEMNonlinearSolver(), MFEMCGSolver::constructSolver(), MFEMHypreFGMRES::constructSolver(), MFEMHyprePCG::constructSolver(), MFEMGMRESSolver::constructSolver(), MFEMHypreGMRES::constructSolver(), MFEMSuperLU::constructSolver(), MFEMCutTransitionSubMesh::labelMesh(), MFEMHyprePCG::updateSolver(), MFEMHypreFGMRES::updateSolver(), and MFEMHypreGMRES::updateSolver().

{ return getProblemData().comm; }

getConsumedPropertyMap()

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

inherited

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

Definition at line 743 of file SubProblem.C.

Referenced by MaterialPropertyDebugOutput::output().

{
  return _consumed_material_properties;
}

getControlWarehouse()

ExecuteMooseObjectWarehouse<Control>& FEProblemBase::getControlWarehouse ( )

inlineinherited

Reference to the control logic warehouse.

Definition at line 2271 of file FEProblemBase.h.

Referenced by LibtorchArtificialNeuralNetParameters::initialSetup(), and LibtorchControlValuePostprocessor::initialSetup().

{ return _control_warehouse; }

getConvergence()

Convergence & FEProblemBase::getConvergence ( const std::string &  name, const THREAD_ID  tid = 0  ) const

virtualinherited

Gets a Convergence object.

Definition at line 2673 of file FEProblemBase.C.

Referenced by TransientBase::convergedToSteadyState(), FEProblemSolve::convergenceSetup(), FixedPointSolve::examineFixedPointConvergence(), FixedPointIterationAdaptiveDT::init(), TransientBase::init(), ParsedConvergence::initializeConvergenceSymbol(), SteffensenSolve::initialSetup(), FixedPointSolve::initialSetup(), Moose::PetscSupport::petscLinearConverged(), Moose::PetscSupport::petscNonlinearConverged(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

{
  auto * const ret = dynamic_cast<Convergence *>(_convergences.getActiveObject(name, tid).get());
  if (!ret)
    mooseError("The Convergence object '", name, "' does not exist.");

  return *ret;
}

getConvergenceObjects()

const std::vector< std::shared_ptr< Convergence > > & FEProblemBase::getConvergenceObjects ( const THREAD_ID  tid = 0 ) const

virtualinherited

Gets the Convergence objects.

Definition at line 2683 of file FEProblemBase.C.

{
  return _convergences.getActiveObjects(tid);
}

getCoordSystem()

Moose::CoordinateSystemType SubProblem::getCoordSystem ( SubdomainID  sid ) const

inherited

Definition at line 1283 of file SubProblem.C.

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

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

getCurrentAlgebraicBndNodeRange()

const ConstBndNodeRange & FEProblemBase::getCurrentAlgebraicBndNodeRange ( )

inherited

Definition at line 9621 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCs(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), NonlinearSystemBase::computeResidualInternal(), and NonlinearSystemBase::setInitialSolution().

{
  if (!_current_algebraic_bnd_node_range)
    return *_mesh.getBoundaryNodeRange();

  return *_current_algebraic_bnd_node_range;
}

getCurrentAlgebraicElementRange()

const ConstElemRange & FEProblemBase::getCurrentAlgebraicElementRange ( )

inherited

These are the element and nodes that contribute to the jacobian and residual for this local processor.

getCurrentAlgebraicElementRange() returns the element range that contributes to the system getCurrentAlgebraicNodeRange() returns the node range that contributes to the system getCurrentAlgebraicBndNodeRange returns the boundary node ranges that contributes to the system

Definition at line 9605 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), and NonlinearSystemBase::computeScaling().

{
  if (!_current_algebraic_elem_range)
    return *_mesh.getActiveLocalElementRange();

  return *_current_algebraic_elem_range;
}

getCurrentAlgebraicNodeRange()

const ConstNodeRange & FEProblemBase::getCurrentAlgebraicNodeRange ( )

inherited

Definition at line 9613 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeJacobianInternal(), and NonlinearSystemBase::computeResidualInternal().

{
  if (!_current_algebraic_node_range)
    return *_mesh.getLocalNodeRange();

  return *_current_algebraic_node_range;
}

getCurrentExecuteOnFlag()

const ExecFlagType & FEProblemBase::getCurrentExecuteOnFlag ( ) const

inherited

Return/set the current execution flag.

Returns EXEC_NONE when not being executed.

See also

FEProblemBase::execute

Definition at line 4778 of file FEProblemBase.C.

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), MultiAppGeneralFieldTransfer::closestToPosition(), MultiAppGeneralFieldNearestLocationTransfer::computeNumSources(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), NearestPositionsDivision::divisionIndex(), PositionsFunctorValueSampler::execute(), PIDTransientControl::execute(), Terminator::execute(), Control::getControllableParameterByName(), Material::getMaterialByName(), MultiAppGeneralFieldNearestLocationTransfer::getNumDivisions(), NumPositions::getValue(), PositionsFunctorValueSampler::initialize(), DistributedPositions::initialize(), TransformedPositions::initialize(), ParsedDownSelectionPositions::initialize(), MultiAppGeneralFieldTransfer::locatePointReceivers(), ComputeUserObjectsThread::printBlockExecutionInformation(), ComputeFVInitialConditionThread::printGeneralExecutionInformation(), ComputeInitialConditionThread::printGeneralExecutionInformation(), ComputeNodalUserObjectsThread::printGeneralExecutionInformation(), ComputeNodalKernelBcsThread::printGeneralExecutionInformation(), ComputeElemDampingThread::printGeneralExecutionInformation(), ComputeNodalKernelsThread::printGeneralExecutionInformation(), ComputeNodalKernelBCJacobiansThread::printGeneralExecutionInformation(), ComputeMarkerThread::printGeneralExecutionInformation(), ComputeNodalDampingThread::printGeneralExecutionInformation(), ComputeDiracThread::printGeneralExecutionInformation(), ComputeNodalKernelJacobiansThread::printGeneralExecutionInformation(), ComputeIndicatorThread::printGeneralExecutionInformation(), ComputeThreadedGeneralUserObjectsThread::printGeneralExecutionInformation(), ComputeUserObjectsThread::printGeneralExecutionInformation(), ComputeLinearFVElementalThread::printGeneralExecutionInformation(), ComputeLinearFVFaceThread::printGeneralExecutionInformation(), NonlinearThread::printGeneralExecutionInformation(), MultiApp::restore(), SolutionInvalidityOutput::shouldOutput(), NodalReporter::shouldStore(), ElementReporter::shouldStore(), GeneralReporter::shouldStore(), and WebServerControl::startServer().

{
  return _current_execute_on_flag;
}

getCurrentICState()

unsigned short FEProblemBase::getCurrentICState ( )

inherited

Retrieves the current initial condition state.

Returns

current initial condition state

Definition at line 9664 of file FEProblemBase.C.

Referenced by ComputeInitialConditionThread::operator()().

{
  return _current_ic_state;
}

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.

Referenced by DataFileInterface::getDataFileNameByName().

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

getDiracElements()

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

overridevirtualinherited

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

Implements SubProblem.

Definition at line 2493 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeDiracContributions().

{
  // First add in the undisplaced elements
  elems = _dirac_kernel_info.getElements();

  if (_displaced_problem)
  {
    std::set<const Elem *> displaced_elements;
    _displaced_problem->getDiracElements(displaced_elements);

    { // Use the ids from the displaced elements to get the undisplaced elements
      // and add them to the list
      for (const auto & elem : displaced_elements)
        elems.insert(_mesh.elemPtr(elem->id()));
    }
  }
}

getDiscreteMaterialWarehouse()

const MaterialWarehouse& FEProblemBase::getDiscreteMaterialWarehouse ( ) const

inlineinherited

Definition at line 2091 of file FEProblemBase.h.

{ return _discrete_materials; }

getDisplacedProblem() [1/2]

virtual std::shared_ptr<const DisplacedProblem> FEProblemBase::getDisplacedProblem ( ) const

inlinevirtualinherited

Definition at line 1786 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::assembleScalingVector(), MooseApp::attachRelationshipManagers(), NonlinearSystemBase::augmentSparsity(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeScaling(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), MultiApp::createApp(), DMMooseGetEmbedding_Private(), DMSetUp_Moose_Pre(), ActivateElementsUserObjectBase::execute(), MultiAppUserObjectTransfer::execute(), ActivateElementsUserObjectBase::finalize(), RadialAverage::finalize(), MultiApp::getBoundingBox(), MultiAppFieldTransfer::getEquationSystem(), Exodus::handleExodusIOMeshRenumbering(), EigenExecutionerBase::init(), Adaptivity::init(), NonlinearSystemBase::initialSetup(), FEProblemBase::initialSetup(), EigenExecutionerBase::inversePowerIteration(), Output::Output(), Exodus::outputSetup(), NonlinearSystemBase::overwriteNodeFace(), NonlinearSystemBase::reinitNodeFace(), NonlinearSystemBase::setConstraintSecondaryValues(), NonlinearSystemBase::setInitialSolution(), and ActivateElementsUserObjectBase::setNewBoundayName().

  {
    return _displaced_problem;
  }

getDisplacedProblem() [2/2]

virtual std::shared_ptr<DisplacedProblem> FEProblemBase::getDisplacedProblem ( )

inlinevirtualinherited

Definition at line 1790 of file FEProblemBase.h.

{ return _displaced_problem; }

getDistribution()

Distribution & FEProblemBase::getDistribution ( const std::string &  name )

virtualinherited

Definition at line 2743 of file FEProblemBase.C.

Referenced by DistributionInterface::getDistribution(), and DistributionInterface::getDistributionByName().

{
  std::vector<Distribution *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>("Distribution")
      .condition<AttribName>(name)
      .queryInto(objs);
  if (objs.empty())
    mooseError("Unable to find Distribution with name '" + name + "'");
  return *(objs[0]);
}

getEvaluableElementRange()

const ConstElemRange & FEProblemBase::getEvaluableElementRange ( )

inherited

In general, {evaluable elements} >= {local elements} U {algebraic ghosting elements}.

That is, the number of evaluable elements does NOT necessarily equal to the number of local and algebraic ghosting elements. For example, if using a Lagrange basis for all variables, if a non-local, non-algebraically-ghosted element is surrounded by neighbors which are local or algebraically ghosted, then all the nodal (Lagrange) degrees of freedom associated with the non-local, non-algebraically-ghosted element will be evaluable, and hence that element will be considered evaluable.

getNonlinearEvaluableElementRange() returns the evaluable element range based on the nonlinear system dofmap; getAuxliaryEvaluableElementRange() returns the evaluable element range based on the auxiliary system dofmap; getEvaluableElementRange() returns the element range that is evaluable based on both the nonlinear dofmap and the auxliary dofmap.

Definition at line 851 of file FEProblemBase.C.

Referenced by NodalPatchRecoveryBase::gatherRequestList().

{
  if (!_evaluable_local_elem_range)
  {
    std::vector<const DofMap *> dof_maps(es().n_systems());
    for (const auto i : make_range(es().n_systems()))
    {
      const auto & sys = es().get_system(i);
      dof_maps[i] = &sys.get_dof_map();
    }
    _evaluable_local_elem_range =
        std::make_unique<ConstElemRange>(_mesh.getMesh().multi_evaluable_elements_begin(dof_maps),
                                         _mesh.getMesh().multi_evaluable_elements_end(dof_maps));
  }
  return *_evaluable_local_elem_range;
}

getExecutor()

virtual Executor& FEProblemBase::getExecutor ( const std::string &  name )

inlinevirtualinherited

Definition at line 2223 of file FEProblemBase.h.

{ return _app.getExecutor(name); }

getFailNextNonlinearConvergenceCheck()

bool FEProblemBase::getFailNextNonlinearConvergenceCheck ( ) const

inlineinherited

Whether it will skip further residual evaluations and fail the next nonlinear convergence check(s)

Definition at line 2611 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::computeScaling(), NonlinearSystem::converged(), Moose::PetscSupport::petscNonlinearConverged(), and ComputeResidualFunctor::residual().

{ return getFailNextSystemConvergenceCheck(); }

getFailNextSystemConvergenceCheck()

bool FEProblemBase::getFailNextSystemConvergenceCheck ( ) const

inlineinherited

Whether it will fail the next system convergence check(s), triggering failed step behavior.

Definition at line 2613 of file FEProblemBase.h.

Referenced by FEProblemBase::getFailNextNonlinearConvergenceCheck(), and Moose::PetscSupport::petscLinearConverged().

{ return _fail_next_system_convergence_check; }

getFunction()

Function & FEProblemBase::getFunction ( const std::string &  name, const THREAD_ID  tid = 0  )

virtualinherited

Definition at line 2622 of file FEProblemBase.C.

Referenced by addFunction(), FunctionInterface::getFunction(), FunctionInterface::getFunctionByName(), IterationAdaptiveDT::init(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), and ParsedConvergence::initializeFunctionSymbol().

{
  // This thread lock is necessary since this method will create functions
  // for all threads if one is missing.
  Threads::spin_mutex::scoped_lock lock(get_function_mutex);

  if (!hasFunction(name, tid))
  {
    // If we didn't find a function, it might be a default function, attempt to construct one now
    std::istringstream ss(name);
    Real real_value;

    // First see if it's just a constant. If it is, build a ConstantFunction
    if (ss >> real_value && ss.eof())
    {
      InputParameters params = _factory.getValidParams("ConstantFunction");
      params.set<Real>("value") = real_value;
      addFunction("ConstantFunction", ss.str(), params);
    }
    else
    {
      FunctionParserBase<Real> fp;
      std::string vars = "x,y,z,t,NaN,pi,e";
      if (fp.Parse(name, vars) == -1) // -1 for success
      {
        // It parsed ok, so build a MooseParsedFunction
        InputParameters params = _factory.getValidParams("ParsedFunction");
        params.set<std::string>("expression") = name;
        addFunction("ParsedFunction", name, params);
      }
    }

    // Try once more
    if (!hasFunction(name, tid))
      mooseError("Unable to find function " + name);
  }

  auto * const ret = dynamic_cast<Function *>(_functions.getActiveObject(name, tid).get());
  if (!ret)
    mooseError("No function named ", name, " of appropriate type");

  return *ret;
}

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  )

inherited

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 1219 of file SubProblem.h.

Referenced by FunctorInterface::getFunctorByName().

{
  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 static_cast<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 static_cast<Moose::Functor<T> &>(*(requested_functor_is_ad
                                                  ? std::get<2>(emplace_ret->second)
                                                  : std::get<1>(emplace_ret->second)));
  }
}

getFVInitialConditionWarehouse()

const FVInitialConditionWarehouse& FEProblemBase::getFVInitialConditionWarehouse ( ) const

inlineinherited

Return FVInitialCondition storage.

Definition at line 1891 of file FEProblemBase.h.

Referenced by ComputeFVInitialConditionThread::operator()(), and ComputeFVInitialConditionThread::printGeneralExecutionInformation().

{ return _fv_ics; }

getFVMatsAndDependencies()

void FEProblemBase::getFVMatsAndDependencies ( SubdomainID  block_id, std::vector< std::shared_ptr< MaterialBase >> &  face_materials, std::vector< std::shared_ptr< MaterialBase >> &  neighbor_materials, std::set< MooseVariableFieldBase *> &  variables, const THREAD_ID  tid  )

inherited

Get the materials and variables potentially needed for FV.

Parameters

block_id	SubdomainID The subdomain id that we want to retrieve materials for
face_materials	The face materials container that we will fill
neighbor_materials	The neighbor materials container that we will fill
variables	The variables container that we will fill that our materials depend on
tid	The thread id

Definition at line 9300 of file FEProblemBase.C.

{
  if (_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
  {
    auto & this_face_mats =
        _materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid);
    for (std::shared_ptr<MaterialBase> face_mat : this_face_mats)
      if (face_mat->ghostable())
      {
        face_materials.push_back(face_mat);
        auto & var_deps = face_mat->getMooseVariableDependencies();
        for (auto * var : var_deps)
        {
          if (!var->isFV())
            mooseError(
                "Ghostable materials should only have finite volume variables coupled into them.");
          else if (face_mat->hasStatefulProperties())
            mooseError("Finite volume materials do not currently support stateful properties.");
          variables.insert(var);
        }
      }
  }

  if (_materials[Moose::NEIGHBOR_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
  {
    auto & this_neighbor_mats =
        _materials[Moose::NEIGHBOR_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid);
    for (std::shared_ptr<MaterialBase> neighbor_mat : this_neighbor_mats)
      if (neighbor_mat->ghostable())
      {
        neighbor_materials.push_back(neighbor_mat);
#ifndef NDEBUG
        auto & var_deps = neighbor_mat->getMooseVariableDependencies();
        for (auto * var : var_deps)
        {
          if (!var->isFV())
            mooseError(
                "Ghostable materials should only have finite volume variables coupled into them.");
          else if (neighbor_mat->hasStatefulProperties())
            mooseError("Finite volume materials do not currently support stateful properties.");
          auto pr = variables.insert(var);
          mooseAssert(!pr.second,
                      "We should not have inserted any new variables dependencies from our "
                      "neighbor materials that didn't exist for our face materials");
        }
#endif
      }
  }
}

getGridFunction()

std::shared_ptr< mfem::ParGridFunction > MFEMProblem::getGridFunction

(

const std::string &

name

)

Returns

a shared pointer to an MFEM parallel grid function

Definition at line 503 of file MFEMProblem.C.

Referenced by MFEMScalarIC::execute(), MFEMVectorIC::execute(), and MFEMScalarBoundaryIC::execute().

{
  return getUserObject<MFEMVariable>(name).getGridFunction();
}

getHitNode()

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.

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

{ return getHitNode(_pars); }

getIndicatorWarehouse()

const MooseObjectWarehouse<Indicator>& FEProblemBase::getIndicatorWarehouse ( )

inlineinherited

Return indicator/marker storage.

Definition at line 1875 of file FEProblemBase.h.

{ return _indicators; }

getInitialConditionWarehouse()

const InitialConditionWarehouse& FEProblemBase::getInitialConditionWarehouse ( ) const

inlineinherited

Return InitialCondition storage.

Definition at line 1886 of file FEProblemBase.h.

Referenced by ComputeBoundaryInitialConditionThread::onNode(), ComputeInitialConditionThread::operator()(), and ComputeInitialConditionThread::printGeneralExecutionInformation().

{ return _ics; }

getInterfaceMaterialsWarehouse()

const MaterialWarehouse& FEProblemBase::getInterfaceMaterialsWarehouse ( ) const

inlineinherited

Definition at line 2092 of file FEProblemBase.h.

{ return _interface_materials; }

getInternalSideIndicatorWarehouse()

const MooseObjectWarehouse<InternalSideIndicatorBase>& FEProblemBase::getInternalSideIndicatorWarehouse ( )

inlineinherited

Definition at line 1876 of file FEProblemBase.h.

  {
    return _internal_side_indicators;
  }

getKokkosBndMaterialPropertyStorage()

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::getKokkosBndMaterialPropertyStorage ( )

inlineinherited

Definition at line 1860 of file FEProblemBase.h.

  {
    return _kokkos_bnd_material_props;
  }

getKokkosMaterialData()

MaterialData& FEProblemBase::getKokkosMaterialData ( Moose::MaterialDataType  type, const MooseObject *  object = nullptr  ) const

inherited

Returns

The Kokkos MaterialData for the type type for thread tid

Referenced by BlockRestrictable::initializeBlockRestrictable().

getKokkosMaterialPropertyStorage()

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::getKokkosMaterialPropertyStorage ( )

inlineinherited

Definition at line 1856 of file FEProblemBase.h.

  {
    return _kokkos_material_props;
  }

getKokkosMaterialPropertyStorageConsumers()

const std::set<const MooseObject *>& FEProblemBase::getKokkosMaterialPropertyStorageConsumers ( Moose::MaterialDataType  type ) const

inherited

Returns

The consumers of the Kokkos MaterialPropertyStorage for the type type

getKokkosMaterialsWarehouse()

const MaterialWarehouse& FEProblemBase::getKokkosMaterialsWarehouse ( ) const

inlineinherited

Definition at line 2098 of file FEProblemBase.h.

{ return _kokkos_materials; }

getKokkosNeighborMaterialPropertyStorage()

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::getKokkosNeighborMaterialPropertyStorage ( )

inlineinherited

Definition at line 1864 of file FEProblemBase.h.

  {
    return _kokkos_neighbor_material_props;
  }

getKokkosSystem() [1/2]

Moose::Kokkos::System& FEProblemBase::getKokkosSystem ( const unsigned int  sys_num )

inherited

Get the Kokkos system of a specified number that is associated with MOOSE nonlinear and auxiliary systems.

Parameters

sys_num

The system number

Returns

The Kokkos system{@

getKokkosSystem() [2/2]

const Moose::Kokkos::System& FEProblemBase::getKokkosSystem ( const unsigned int  sys_num ) const

inherited

getKokkosSystems() [1/2]

Moose::Kokkos::Array<Moose::Kokkos::System>& FEProblemBase::getKokkosSystems ( )

inlineinherited

Get all Kokkos systems that are associated with MOOSE nonlinear and auxiliary systems.

Returns

The array of Kokkos systems{@

Definition at line 792 of file FEProblemBase.h.

{ return _kokkos_systems; }

getKokkosSystems() [2/2]

const Moose::Kokkos::Array<Moose::Kokkos::System>& FEProblemBase::getKokkosSystems ( ) const

inlineinherited

Definition at line 793 of file FEProblemBase.h.

  {
    return _kokkos_systems;
  }

getLinearConvergenceNames()

const std::vector< ConvergenceName > & FEProblemBase::getLinearConvergenceNames ( ) const

inherited

Gets the linear convergence object name(s).

Definition at line 9409 of file FEProblemBase.C.

Referenced by Moose::PetscSupport::petscLinearConverged().

{
  if (_linear_convergence_names)
    return *_linear_convergence_names;
  mooseError("The linear convergence name(s) have not been set.");
}

getLinearSystem() [1/2]

LinearSystem & FEProblemBase::getLinearSystem ( unsigned int  sys_num )

inlineinherited

Get non-constant reference to a linear system.

Parameters

sys_num

The number of the linear system

Definition at line 3477 of file FEProblemBase.h.

Referenced by IterationAdaptiveDT::acceptStep(), Moose::compute_linear_system(), ComputeLinearFVGreenGaussGradientFaceThread::operator()(), ComputeLinearFVGreenGaussGradientVolumeThread::operator()(), Moose::PetscSupport::petscSetDefaults(), and FEProblemSolve::solve().

{
  mooseAssert(sys_num < _linear_systems.size(),
              "System number greater than the number of linear systems");
  return *_linear_systems[sys_num];
}

getLinearSystem() [2/2]

const LinearSystem & FEProblemBase::getLinearSystem ( unsigned int  sys_num ) const

inlineinherited

Get a constant reference to a linear system.

Parameters

sys_num

The number of the linear system

Definition at line 3485 of file FEProblemBase.h.

{
  mooseAssert(sys_num < _linear_systems.size(),
              "System number greater than the number of linear systems");
  return *_linear_systems[sys_num];
}

getLinearSystemNames()

const std::vector<LinearSystemName>& FEProblemBase::getLinearSystemNames ( ) const

inlineinherited

Returns

the linear system names in the problem

Definition at line 2692 of file FEProblemBase.h.

Referenced by PhysicsBase::initializePhysics(), and MultiSystemSolveObject::MultiSystemSolveObject().

{ return _linear_sys_names; }

getLineSearch()

LineSearch* FEProblemBase::getLineSearch ( )

inlineoverridevirtualinherited

getter for the MOOSE line search

Implements SubProblem.

Definition at line 752 of file FEProblemBase.h.

Referenced by DisplacedProblem::getLineSearch().

{ return _line_search.get(); }

getMarkerWarehouse()

const MooseObjectWarehouse<Marker>& FEProblemBase::getMarkerWarehouse ( )

inlineinherited

Definition at line 1880 of file FEProblemBase.h.

{ return _markers; }

getMaterial()

std::shared_ptr< MaterialBase > FEProblemBase::getMaterial ( std::string  name, Moose::MaterialDataType  type, const THREAD_ID  tid = 0, bool  no_warn = false  )

inherited

Return a pointer to a MaterialBase object.

If no_warn is true, suppress warning about retrieving a material reference potentially during the material's calculation.

This will return enabled or disabled objects, the main purpose is for iterative materials.

Definition at line 3878 of file FEProblemBase.C.

Referenced by MaterialPropertyInterface::getMaterialByName().

{
  switch (type)
  {
    case Moose::NEIGHBOR_MATERIAL_DATA:
      name += "_neighbor";
      break;
    case Moose::FACE_MATERIAL_DATA:
      name += "_face";
      break;
    default:
      break;
  }

  std::shared_ptr<MaterialBase> material = _all_materials[type].getActiveObject(name, tid);
  if (!no_warn && material->getParam<bool>("compute") && type == Moose::BLOCK_MATERIAL_DATA)
    mooseWarning("You are retrieving a Material object (",
                 material->name(),
                 "), but its compute flag is set to true. This indicates that MOOSE is "
                 "computing this property which may not be desired and produce un-expected "
                 "results.");

  return material;
}

getMaterialData()

MaterialData & FEProblemBase::getMaterialData ( Moose::MaterialDataType  type, const THREAD_ID  tid = 0, const MooseObject *  object = nullptr  ) const

inherited

Returns

The MaterialData for the type type for thread tid

Definition at line 3907 of file FEProblemBase.C.

Referenced by BlockRestrictable::initializeBlockRestrictable(), and FEProblemBase::resizeMaterialData().

{
  switch (type)
  {
    case Moose::BLOCK_MATERIAL_DATA:
      if (object)
        _material_props.addConsumer(type, object);
      return _material_props.getMaterialData(tid);
    case Moose::NEIGHBOR_MATERIAL_DATA:
      if (object)
        _neighbor_material_props.addConsumer(type, object);
      return _neighbor_material_props.getMaterialData(tid);
    case Moose::BOUNDARY_MATERIAL_DATA:
    case Moose::FACE_MATERIAL_DATA:
    case Moose::INTERFACE_MATERIAL_DATA:
      if (object)
        _bnd_material_props.addConsumer(type, object);
      return _bnd_material_props.getMaterialData(tid);
  }

  mooseError("FEProblemBase::getMaterialData(): Invalid MaterialDataType ", type);
}

getMaterialPropertyBlockNames()

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

virtualinherited

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

Definition at line 490 of file SubProblem.C.

Referenced by MaterialPropertyInterface::getMaterialPropertyBlockNames().

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

getMaterialPropertyBlocks()

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

virtualinherited

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

Definition at line 474 of file SubProblem.C.

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

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

getMaterialPropertyBoundaryIDs()

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

virtualinherited

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

Definition at line 526 of file SubProblem.C.

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

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

getMaterialPropertyBoundaryNames()

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

virtualinherited

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

Definition at line 542 of file SubProblem.C.

Referenced by MaterialPropertyInterface::getMaterialPropertyBoundaryNames().

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

getMaterialPropertyRegistry()

const MaterialPropertyRegistry& FEProblemBase::getMaterialPropertyRegistry ( ) const

inlineinherited

Returns

A reference to the material property registry

Definition at line 1838 of file FEProblemBase.h.

Referenced by MaterialBase::checkStatefulSanity().

  {
    return _material_prop_registry;
  }

getMaterialPropertyStorage()

const MaterialPropertyStorage& FEProblemBase::getMaterialPropertyStorage ( )

inlineinherited

Return a reference to the material property storage.

Returns

A const reference to the material property storage

Definition at line 1848 of file FEProblemBase.h.

{ return _material_props; }

getMaterialPropertyStorageConsumers()

const std::set< const MooseObject * > & FEProblemBase::getMaterialPropertyStorageConsumers ( Moose::MaterialDataType  type ) const

inherited

Returns

The consumers of the MaterialPropertyStorage for the type type

Definition at line 3933 of file FEProblemBase.C.

{
  switch (type)
  {
    case Moose::BLOCK_MATERIAL_DATA:
      return _material_props.getConsumers(type);
    case Moose::NEIGHBOR_MATERIAL_DATA:
      return _neighbor_material_props.getConsumers(type);
    case Moose::BOUNDARY_MATERIAL_DATA:
    case Moose::FACE_MATERIAL_DATA:
    case Moose::INTERFACE_MATERIAL_DATA:
      return _bnd_material_props.getConsumers(type);
  }

  mooseError("FEProblemBase::getMaterialPropertyStorageConsumers(): Invalid MaterialDataType ",
             type);
}

getMaterialWarehouse()

const MaterialWarehouse& FEProblemBase::getMaterialWarehouse ( ) const

inlineinherited

Definition at line 2085 of file FEProblemBase.h.

Referenced by MaterialPropertyInterface::buildRequiredMaterials(), BlockRestrictable::hasBlockMaterialPropertyHelper(), BoundaryRestrictable::hasBoundaryMaterialPropertyHelper(), ElementSubdomainModifierBase::modify(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), MaterialPropertyDebugOutput::printMaterialMap(), ComputeIndicatorThread::subdomainChanged(), NonlinearThread::subdomainChanged(), and ComputeUserObjectsThread::subdomainChanged().

{ return _all_materials; }

getMatrixTagID()

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

virtualinherited

Get a TagID from a TagName.

Reimplemented in DisplacedProblem.

Definition at line 343 of file SubProblem.C.

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

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

getMatrixTags()

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

inlinevirtualinherited

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

Definition at line 253 of file SubProblem.h.

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

{ return _matrix_tag_name_to_tag_id; }

getMaxQps()

unsigned int FEProblemBase::getMaxQps ( ) const

inherited

Returns

The maximum number of quadrature points in use on any element in this problem.

Definition at line 1639 of file FEProblemBase.C.

Referenced by MaterialBase::getMaxQps(), MaterialPropertyInterface::getMaxQps(), FEProblemBase::initialSetup(), FEProblemBase::reinitDirac(), Material::subdomainSetup(), and FEProblemBase::updateMaxQps().

{
  if (_max_qps == std::numeric_limits<unsigned int>::max())
    mooseError("Max QPS uninitialized");
  return _max_qps;
}

getMaxScalarOrder()

Order FEProblemBase::getMaxScalarOrder ( ) const

inherited

Returns

The maximum order for all scalar variables in this problem's systems.

Definition at line 1647 of file FEProblemBase.C.

Referenced by ScalarCoupleable::coupledScalarOrder(), ScalarCoupleable::getADDefaultValue(), and ScalarCoupleable::getDefaultValue().

{
  return _max_scalar_order;
}

getMeshDisplacementGridFunction()

std::optional< std::reference_wrapper< mfem::ParGridFunction const > > MFEMProblem::getMeshDisplacementGridFunction

(

)

Returns optional reference to the displacement GridFunction to apply to nodes.

Definition at line 445 of file MFEMProblem.C.

Referenced by displaceMesh().

{
  // If C++23 transform were available this would be easier
  auto const displacement_variable = mesh().getMeshDisplacementVariable();
  if (displacement_variable)
  {
    return *_problem_data.gridfunctions.Get(displacement_variable.value());
  }
  else
  {
    return std::nullopt;
  }
}

getMeshDivision()

MeshDivision & FEProblemBase::getMeshDivision ( const std::string &  name, const THREAD_ID  tid = 0  ) const

inherited

Get a MeshDivision.

Definition at line 2704 of file FEProblemBase.C.

Referenced by NestedDivision::NestedDivision().

{
  auto * const ret = dynamic_cast<MeshDivision *>(_mesh_divisions.getActiveObject(name, tid).get());
  if (!ret)
    mooseError("No MeshDivision object named ", name, " of appropriate type");
  return *ret;
}

getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), ReporterTransferInterface::checkHasReporterValue(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Coupleable::Coupleable(), MortarInterfaceWarehouse::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), DefaultConvergenceBase::getSharedExecutionerParam(), ChainControlDataPostprocessor::initialSetup(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

{ return _app; }

getMortarInterface() [1/2]

const AutomaticMortarGeneration & FEProblemBase::getMortarInterface ( const std::pair< BoundaryID, BoundaryID > &  primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &  primary_secondary_subdomain_pair, bool  on_displaced  ) const

inherited

Return the undisplaced or displaced mortar generation object associated with the provided boundaries and subdomains.

Definition at line 8073 of file FEProblemBase.C.

{
  return _mortar_data->getMortarInterface(
      primary_secondary_boundary_pair, primary_secondary_subdomain_pair, on_displaced);
}

getMortarInterface() [2/2]

AutomaticMortarGeneration & FEProblemBase::getMortarInterface ( const std::pair< BoundaryID, BoundaryID > &  primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &  primary_secondary_subdomain_pair, bool  on_displaced  )

inherited

Definition at line 8083 of file FEProblemBase.C.

{
  return _mortar_data->getMortarInterface(
      primary_secondary_boundary_pair, primary_secondary_subdomain_pair, on_displaced);
}

getMortarInterfaces()

const std::unordered_map< std::pair< BoundaryID, BoundaryID >, std::unique_ptr< AutomaticMortarGeneration > > & FEProblemBase::getMortarInterfaces ( bool  on_displaced ) const

inherited

Definition at line 9698 of file FEProblemBase.C.

Referenced by FEProblemBase::computeUserObjectsInternal(), and NonlinearSystemBase::initialSetup().

{
  return _mortar_data->getMortarInterfaces(on_displaced);
}

getMultiApp()

std::shared_ptr< MultiApp > FEProblemBase::getMultiApp ( const std::string &  multi_app_name ) const

inherited

Get a MultiApp object by name.

Definition at line 5532 of file FEProblemBase.C.

Referenced by FEProblemBase::addTransfer(), MultiAppPositions::initialize(), and MultiAppTransfer::MultiAppTransfer().

{
  return _multi_apps.getObject(multi_app_name);
}

getMultiAppFixedPointConvergenceName()

const ConvergenceName & FEProblemBase::getMultiAppFixedPointConvergenceName ( ) const

inherited

Gets the MultiApp fixed point convergence object name.

Definition at line 9417 of file FEProblemBase.C.

Referenced by FEProblemBase::addDefaultMultiAppFixedPointConvergence(), FixedPointSolve::examineFixedPointConvergence(), FixedPointIterationAdaptiveDT::init(), SteffensenSolve::initialSetup(), FixedPointSolve::initialSetup(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

{
  if (_multiapp_fixed_point_convergence_name)
    return _multiapp_fixed_point_convergence_name.value();
  else
    mooseError("The fixed point convergence name has not been set.");
}

getMultiAppTransferWarehouse()

const ExecuteMooseObjectWarehouse< Transfer > & FEProblemBase::getMultiAppTransferWarehouse ( Transfer::DIRECTION  direction ) const

inherited

Return the complete warehouse for MultiAppTransfer object for the given direction.

Definition at line 5627 of file FEProblemBase.C.

{
  if (direction == MultiAppTransfer::TO_MULTIAPP)
    return _to_multi_app_transfers;
  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
    return _from_multi_app_transfers;
  else
    return _between_multi_app_transfers;
}

getMultiAppWarehouse()

ExecuteMooseObjectWarehouse<MultiApp>& FEProblemBase::getMultiAppWarehouse ( )

inlineinherited

Definition at line 2295 of file FEProblemBase.h.

Referenced by MooseApp::errorCheck().

{ return _multi_apps; }

getNeighborMaterialPropertyStorage()

const MaterialPropertyStorage& FEProblemBase::getNeighborMaterialPropertyStorage ( )

inlineinherited

Definition at line 1850 of file FEProblemBase.h.

  {
    return _neighbor_material_props;
  }

getNonlinearConvergenceNames()

const std::vector< ConvergenceName > & FEProblemBase::getNonlinearConvergenceNames ( ) const

inherited

Gets the nonlinear system convergence object name(s).

Definition at line 9385 of file FEProblemBase.C.

Referenced by ReferenceResidualProblem::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), FEProblemSolve::convergenceSetup(), and Moose::PetscSupport::petscNonlinearConverged().

{
  if (_nonlinear_convergence_names)
    return *_nonlinear_convergence_names;
  mooseError("The nonlinear system convergence name(s) have not been set.");
}

getNonlinearEvaluableElementRange()

const ConstElemRange & FEProblemBase::getNonlinearEvaluableElementRange ( )

inherited

Definition at line 869 of file FEProblemBase.C.

Referenced by ElemSideNeighborLayersTester::execute().

{
  if (!_nl_evaluable_local_elem_range)
  {
    std::vector<const DofMap *> dof_maps(_nl.size());
    for (const auto i : index_range(dof_maps))
      dof_maps[i] = &_nl[i]->dofMap();
    _nl_evaluable_local_elem_range =
        std::make_unique<ConstElemRange>(_mesh.getMesh().multi_evaluable_elements_begin(dof_maps),
                                         _mesh.getMesh().multi_evaluable_elements_end(dof_maps));
  }

  return *_nl_evaluable_local_elem_range;
}

getNonlinearSystem()

NonlinearSystem & FEProblemBase::getNonlinearSystem ( const unsigned int  sys_num )

virtualinherited

Reimplemented in FEProblem.

Definition at line 2719 of file FEProblemBase.C.

Referenced by PNGOutput::calculateRescalingValues(), and PNGOutput::makeMeshFunc().

{
  mooseDeprecated("FEProblemBase::getNonlinearSystem() is deprecated, please use "
                  "FEProblemBase::getNonlinearSystemBase() \n");

  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
  auto nl_sys = std::dynamic_pointer_cast<NonlinearSystem>(_nl[sys_num]);

  if (!nl_sys)
    mooseError("This is not a NonlinearSystem");

  return *nl_sys;
}

getNonlinearSystemBase() [1/2]

NonlinearSystemBase & FEProblemBase::getNonlinearSystemBase ( const unsigned int  sys_num )

inlineinherited

Definition at line 3433 of file FEProblemBase.h.

Referenced by IterationAdaptiveDT::acceptStep(), Adaptivity::adaptMesh(), DisplacedProblem::addTimeIntegrator(), ADKernelTempl< T >::ADKernelTempl(), ElementSubdomainModifierBase::applyIC(), ArrayKernel::ArrayKernel(), Eigenvalue::checkIntegrity(), PseudoTimestep::currentResidualNorm(), DisplacedProblem::DisplacedProblem(), AB2PredictorCorrector::estimateTimeError(), VariableResidual::execute(), MatrixSymmetryCheck::execute(), GreaterThanLessThanPostprocessor::execute(), Executioner::Executioner(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), NumResidualEvaluations::getValue(), Residual::getValue(), Adaptivity::init(), ReferenceResidualConvergence::initialSetup(), ActivateElementsUserObjectBase::initSolutions(), Kernel::Kernel(), BoundaryElemIntegrityCheckThread::operator()(), DOFMapOutput::output(), SolutionHistory::output(), ConsoleUtils::outputExecutionInformation(), Console::outputSystemInformation(), Moose::PetscSupport::petscSetDefaults(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Moose::PetscSupport::setLineSearchFromParams(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), AB2PredictorCorrector::step(), DisplacedProblem::syncSolutions(), and Console::writeVariableNorms().

{
  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
  return *_nl[sys_num];
}

getNonlinearSystemBase() [2/2]

const NonlinearSystemBase & FEProblemBase::getNonlinearSystemBase ( const unsigned int  sys_num ) const

inlineinherited

Definition at line 3440 of file FEProblemBase.h.

{
  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
  return *_nl[sys_num];
}

getNonlinearSystemNames()

const std::vector<NonlinearSystemName>& FEProblemBase::getNonlinearSystemNames ( ) const

inlineinherited

Returns

the nolinear system names in the problem

Definition at line 2688 of file FEProblemBase.h.

Referenced by PhysicsBase::initializePhysics(), Console::meshChanged(), MultiSystemSolveObject::MultiSystemSolveObject(), ConsoleUtils::outputExecutionInformation(), and Console::outputSystemInformation().

{ return _nl_sys_names; }

getNumCyclesCompleted()

unsigned int FEProblemBase::getNumCyclesCompleted ( )

inlineinherited

Returns

The number of adaptivity cycles completed.

Definition at line 1916 of file FEProblemBase.h.

{ return _cycles_completed; }

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 388 of file MooseBase.h.

Referenced by CreateDisplacedProblemAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FEProblemBase::addOutput(), DiffusionPhysicsBase::addPostprocessors(), ADNodalKernel::ADNodalKernel(), ArrayParsedAux::ArrayParsedAux(), AddPeriodicBCAction::autoTranslationBoundaries(), BicubicSplineFunction::BicubicSplineFunction(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), ComponentPhysicsInterface::ComponentPhysicsInterface(), FunctorAux::computeValue(), Console::Console(), FEProblemBase::createTagSolutions(), CutMeshByLevelSetGenerator::CutMeshByLevelSetGenerator(), DebugResidualAux::DebugResidualAux(), AccumulateReporter::declareLateValues(), DerivativeParsedMaterialTempl< is_ad >::DerivativeParsedMaterialTempl(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), EigenKernel::EigenKernel(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), FEProblemSolve::FEProblemSolve(), ParsedVectorReporter::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), ParsedSubdomainGeneratorBase::functionInitialize(), FVInterfaceKernel::FVInterfaceKernel(), BoundaryLayerSubdomainGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), BlockDeletionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), GeneratedMeshGenerator::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), MeshExtruderGenerator::generate(), GenericConstantRankTwoTensorTempl< is_ad >::GenericConstantRankTwoTensorTempl(), GenericConstantSymmetricRankTwoTensorTempl< is_ad >::GenericConstantSymmetricRankTwoTensorTempl(), GeometricSearchInterface::GeometricSearchInterface(), MooseApp::getCheckpointDirectories(), DataFileInterface::getDataFileName(), ExecutorInterface::getExecutor(), GhostingUserObject::GhostingUserObject(), FixedPointIterationAdaptiveDT::init(), TimeSequenceStepper::init(), IterationAdaptiveDT::init(), AdvancedOutput::init(), AttribThread::initFrom(), AttribSysNum::initFrom(), AttribResidualObject::initFrom(), AttribDisplaced::initFrom(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), Console::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseMesh::MooseMesh(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MultiSystemSolveObject::MultiSystemSolveObject(), NEML2ModelExecutor::NEML2ModelExecutor(), NestedDivision::NestedDivision(), 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(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), PiecewiseConstantByBlockMaterialTempl< is_ad >::PiecewiseConstantByBlockMaterialTempl(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), Moose::FV::setInterpolationMethod(), SetupMeshAction::setupMesh(), Output::setWallTimeIntervalFromCommandLineParam(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), TimePeriod::TimePeriod(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), and VectorOfPostprocessors::VectorOfPostprocessors().

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

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 425 of file MooseBase.h.

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

getPetscOptions()

Moose::PetscSupport::PetscOptions& FEProblemBase::getPetscOptions ( )

inlineinherited

Retrieve a writable reference the PETSc options (used by PetscSupport)

Definition at line 631 of file FEProblemBase.h.

Referenced by Moose::PetscSupport::dontAddCommonKSPOptions(), Moose::PetscSupport::dontAddCommonSNESOptions(), Moose::PetscSupport::dontAddLinearConvergedReason(), Moose::PetscSupport::dontAddNonlinearConvergedReason(), Eigenvalue::Eigenvalue(), Moose::PetscSupport::isSNESVI(), ConsoleUtils::outputExecutionInformation(), Moose::PetscSupport::setConvergedReasonFlags(), Moose::SlepcSupport::setSlepcEigenSolverTolerances(), Split::setup(), Moose::SlepcSupport::slepcSetOptions(), FEProblemSolve::solve(), and Moose::PetscSupport::storePetscOptions().

{ return _petsc_options; }

getPositionsObject()

const Positions & FEProblemBase::getPositionsObject ( const std::string &  name ) const

inherited

Get the Positions object by its name.

Parameters

name	The name of the Positions object being retrieved

Returns

Const reference to the Positions object

Definition at line 4600 of file FEProblemBase.C.

Referenced by DistributedPositions::DistributedPositions(), MultiApp::fillPositions(), ParsedDownSelectionPositions::initialize(), Positions::initialized(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), and TransformedPositions::TransformedPositions().

{
  std::vector<Positions *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>("UserObject")
      .condition<AttribName>(name)
      .queryInto(objs);
  if (objs.empty())
    mooseError("Unable to find Positions object with name '" + name + "'");
  mooseAssert(objs.size() == 1, "Should only find one Positions");
  return *(objs[0]);
}

getPostprocessorValueByName()

const PostprocessorValue & FEProblemBase::getPostprocessorValueByName ( const PostprocessorName &  name, std::size_t  t_index = 0  ) const

inherited

Get a read-only reference to the value associated with a Postprocessor that exists.

Parameters

name	The name of the post-processor
t_index	Flag for getting current (0), old (1), or older (2) values

Returns

The reference to the value at the given time index

Note: This method is only for retrieving values that already exist, the Postprocessor and PostprocessorInterface objects should be used rather than this method for creating and getting values within objects.

Definition at line 4634 of file FEProblemBase.C.

Referenced by addPostprocessor(), MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiApp::appPostprocessorValue(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), EigenProblem::formNorm(), MooseParsedFunctionWrapper::initialize(), ParsedConvergence::initializePostprocessorSymbol(), EigenExecutionerBase::inversePowerIteration(), Exodus::outputPostprocessors(), TableOutput::outputPostprocessorsRow(), EigenProblem::postScaleEigenVector(), and TableOutput::shouldOutputPostprocessorsRow().

{
  return _reporter_data.getReporterValue<PostprocessorValue>(PostprocessorReporterName(name),
                                                             t_index);
}

getProblemData()

MFEMProblemData& MFEMProblem::getProblemData ( )

inline

Method to get the current MFEMProblemData object storing the current data specifying the FE problem.

Definition at line 186 of file MFEMProblem.h.

Referenced by addBoundaryCondition(), addFESpace(), addGridFunction(), addKernel(), addMFEMNonlinearSolver(), addMFEMSolver(), addSubMesh(), getComm(), MFEMCutTransitionSubMesh::labelMesh(), MFEMSumAux::MFEMSumAux(), setMesh(), solverTypeString(), and MultiAppMFEMCopyTransfer::transfer().

{ return _problem_data; }

getRegularMaterialsWarehouse()

const MaterialWarehouse& FEProblemBase::getRegularMaterialsWarehouse ( ) const

inlineinherited

Definition at line 2090 of file FEProblemBase.h.

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

{ return _materials; }

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 402 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 + "'");
}

getReporterData() [1/2]

const ReporterData& FEProblemBase::getReporterData ( ) const

inlineinherited

Provides const access the ReporterData object.

NOTE: There is a private non-const version of this function that uses a key object only constructable by the correct interfaces. This was done by design to encourage the use of the Reporter and ReporterInterface classes.

Definition at line 1257 of file FEProblemBase.h.

Referenced by ReporterTransferInterface::addReporterTransferMode(), ReporterTransferInterface::checkHasReporterValue(), ReporterTransferInterface::clearVectorReporter(), ConstantPostprocessor::ConstantPostprocessor(), AccumulateReporter::declareAccumulateHelper(), ReporterTransferInterface::declareClone(), AccumulateReporter::declareLateValues(), VectorPostprocessor::declareVector(), ReporterTransferInterface::declareVectorClone(), FEProblemBase::execute(), PostprocessorInterface::getPostprocessorValueByNameInternal(), VectorPostprocessorInterface::getVectorPostprocessorByNameHelper(), VectorPostprocessorInterface::getVectorPostprocessorContextByNameHelper(), PostprocessorInterface::hasPostprocessorByName(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), ReporterPositions::initialize(), ReporterTimes::initialize(), MooseParsedFunctionWrapper::initialize(), ParsedConvergence::initializeSymbols(), JSONOutput::initialSetup(), PostprocessorInterface::isDefaultPostprocessorValueByName(), ReporterDebugOutput::output(), Receiver::Receiver(), ReporterTransferInterface::resizeReporter(), ReporterTransferInterface::sumVectorReporter(), ReporterTransferInterface::transferFromVectorReporter(), ReporterTransferInterface::transferReporter(), and ReporterTransferInterface::transferToVectorReporter().

{ return _reporter_data; }

getReporterData() [2/2]

ReporterData& FEProblemBase::getReporterData ( ReporterData::WriteKey  )

inlineinherited

Provides non-const access the ReporterData object that is used to store reporter values.

see ReporterData.h

Definition at line 1264 of file FEProblemBase.h.

{ return _reporter_data; }

getRestartableData()

template<typename T , typename... Args>

const T & Restartable::getRestartableData ( const std::string &  data_name ) const

protectedinherited

Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object.

Forwarded arguments are not allowed in this case because we assume that the object is restarted and we won't need different constructors to initialize it.

NOTE: This returns a const reference! Make sure you store it in a const reference!

Parameters

data_name

The name of the data (usually just use the same name as the member variable)

Definition at line 294 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, nullptr).get();
}

getRestartableEquationSystems()

const RestartableEquationSystems & FEProblemBase::getRestartableEquationSystems ( ) const

inherited

Get the RestartableEquationSystems object.

Definition at line 6010 of file FEProblemBase.C.

{
  return _req.get();
}

getSampler()

Sampler & FEProblemBase::getSampler ( const std::string &  name, const THREAD_ID  tid = 0  )

virtualinherited

Definition at line 2767 of file FEProblemBase.C.

Referenced by SamplerInterface::getSampler(), and SamplerInterface::getSamplerByName().

{
  std::vector<Sampler *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>("Sampler")
      .condition<AttribThread>(tid)
      .condition<AttribName>(name)
      .queryInto(objs);
  if (objs.empty())
    mooseError(
        "Unable to find Sampler with name '" + name +
        "', if you are attempting to access this object in the constructor of another object then "
        "the object being retrieved must occur prior to the caller within the input file.");
  return *(objs[0]);
}

getScalarVariable()

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

overridevirtualinherited

Returns the scalar variable reference from whichever system contains it.

Implements SubProblem.

Definition at line 5986 of file FEProblemBase.C.

Referenced by FEProblemBase::addInitialCondition(), EigenProblem::adjustEigenVector(), MultiAppScalarToAuxScalarTransfer::execute(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), TableOutput::outputScalarVariables(), and Exodus::outputScalarVariables().

{
  for (auto & sys : _solver_systems)
    if (sys->hasScalarVariable(var_name))
      return sys->getScalarVariable(tid, var_name);
  if (_aux->hasScalarVariable(var_name))
    return _aux->getScalarVariable(tid, var_name);

  mooseError("Unknown variable " + var_name);
}

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 72 of file MooseObject.C.

Referenced by addBoundaryCondition(), addKernel(), and addMFEMSolver().

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

getSharedPtr() [2/2]

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

inherited

Definition at line 85 of file MooseObject.C.

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

getSolverSystem() [1/2]

SolverSystem & FEProblemBase::getSolverSystem ( unsigned int  sys_num )

inlineinherited

Get non-constant reference to a solver system.

Parameters

sys_num

The number of the solver system

Definition at line 3447 of file FEProblemBase.h.

Referenced by MooseApp::attachRelationshipManagers(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), MultiSystemSolveObject::MultiSystemSolveObject(), ConsoleUtils::outputSolverSystemInformation(), Moose::PetscSupport::petscSetDefaultKSPNormType(), and Moose::PetscSupport::petscSetDefaultPCSide().

{
  mooseAssert(sys_num < _solver_systems.size(),
              "System number greater than the number of solver systems");
  return *_solver_systems[sys_num];
}

getSolverSystem() [2/2]

const SolverSystem & FEProblemBase::getSolverSystem ( unsigned int  sys_num ) const

inlineinherited

Get a constant reference to a solver system.

Parameters

sys_num

The number of the solver system

Definition at line 3455 of file FEProblemBase.h.

{
  mooseAssert(sys_num < _solver_systems.size(),
              "System number greater than the number of solver systems");
  return *_solver_systems[sys_num];
}

getSolverSystemNames()

const std::vector<SolverSystemName>& FEProblemBase::getSolverSystemNames ( ) const

inlineinherited

Returns

the solver system names in the problem

Definition at line 2696 of file FEProblemBase.h.

Referenced by ConsoleUtils::outputExecutionInformation().

{ return _solver_sys_names; }

getStandardVariable()

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

overridevirtualinherited

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

Implements SubProblem.

Definition at line 5926 of file FEProblemBase.C.

Referenced by CoupleableMooseVariableDependencyIntermediateInterface::coupledValueByName(), FEProblemBase::projectFunctionOnCustomRange(), LinearFVKernel::requestVariableCellGradient(), and ElementSubdomainModifierBase::storeOverriddenDofValues().

{
  for (auto & sys : _solver_systems)
    if (sys->hasVariable(var_name))
      return sys->getFieldVariable<Real>(tid, var_name);
  if (_aux->hasVariable(var_name))
    return _aux->getFieldVariable<Real>(tid, var_name);

  mooseError("Unknown variable " + var_name);
}

getSteadyStateConvergenceName()

const ConvergenceName & FEProblemBase::getSteadyStateConvergenceName ( ) const

inherited

Gets the steady-state detection convergence object name.

Definition at line 9426 of file FEProblemBase.C.

Referenced by FEProblemBase::addDefaultSteadyStateConvergence(), TransientBase::convergedToSteadyState(), and TransientBase::init().

{
  if (_steady_state_convergence_name)
    return _steady_state_convergence_name.value();
  else
    mooseError("The steady convergence name has not been set.");
}

getSystem()

System & FEProblemBase::getSystem ( const std::string &  var_name )

overridevirtualinherited

Returns the equation system containing the variable provided.

Implements SubProblem.

Definition at line 5998 of file FEProblemBase.C.

Referenced by FEProblemBase::addObjectParamsHelper(), MultiApp::appTransferVector(), ElementSubdomainModifierBase::gatherPatchElements(), FEProblemBase::projectFunctionOnCustomRange(), and ElementSubdomainModifierBase::storeOverriddenDofValues().

{
  const auto [var_in_sys, sys_num] = determineSolverSystem(var_name);
  if (var_in_sys)
    return _solver_systems[sys_num]->system();
  else if (_aux->hasVariable(var_name) || _aux->hasScalarVariable(var_name))
    return _aux->system();
  else
    mooseError("Unable to find a system containing the variable " + var_name);
}

getSystemBase() [1/3]

const SystemBase & FEProblemBase::getSystemBase ( const unsigned int  sys_num ) const

virtualinherited

Get constant reference to a system in this problem.

Parameters

sys_num

The number of the system

Definition at line 9139 of file FEProblemBase.C.

Referenced by FEProblemBase::addObjectParamsHelper(), PhysicsBase::copyVariablesFromMesh(), FEProblemBase::getSystemBase(), FEProblemBase::projectFunctionOnCustomRange(), and ElementSubdomainModifierBase::restoreOverriddenDofValues().

{
  if (sys_num < _solver_systems.size())
    return *_solver_systems[sys_num];

  return *_aux;
}

getSystemBase() [2/3]

SystemBase & FEProblemBase::getSystemBase ( const unsigned int  sys_num )

virtualinherited

Get non-constant reference to a system in this problem.

Parameters

sys_num

The number of the system

Definition at line 9160 of file FEProblemBase.C.

{
  if (sys_num < _solver_systems.size())
    return *_solver_systems[sys_num];

  return *_aux;
}

getSystemBase() [3/3]

SystemBase & FEProblemBase::getSystemBase ( const std::string &  sys_name )

inherited

Get non-constant reference to a system in this problem.

Parameters

sys_name

The name of the system

Definition at line 9148 of file FEProblemBase.C.

{
  if (std::find(_solver_sys_names.begin(), _solver_sys_names.end(), sys_name) !=
      _solver_sys_names.end())
    return getSystemBase(solverSysNum(sys_name));
  else if (sys_name == "aux0")
    return *_aux;
  else
    mooseError("System '" + sys_name + "' was requested from problem but does not exist.");
}

getTimeFromStateArg()

Real FEProblemBase::getTimeFromStateArg ( const Moose::StateArg &  state ) const

inherited

Returns the time associated with the requested state.

Definition at line 6978 of file FEProblemBase.C.

Referenced by Function::evaluate(), Function::evaluateDotHelper(), Function::evaluateGradientHelper(), Function::evaluateHelper(), and ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl().

{
  if (state.iteration_type != Moose::SolutionIterationType::Time)
    // If we are any iteration type other than time (e.g. nonlinear), then temporally we are still
    // in the present time
    return time();

  switch (state.state)
  {
    case 0:
      return time();

    case 1:
      return timeOld();

    default:
      mooseError("Unhandled state ", state.state, " in FEProblemBase::getTimeFromStateArg");
  }
}

getTransfers() [1/2]

std::vector< std::shared_ptr< Transfer > > FEProblemBase::getTransfers ( ExecFlagType  type, Transfer::DIRECTION  direction  ) const

inherited

Get Transfers by ExecFlagType and direction.

Definition at line 5605 of file FEProblemBase.C.

{
  if (direction == MultiAppTransfer::TO_MULTIAPP)
    return _to_multi_app_transfers[type].getActiveObjects();
  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
    return _from_multi_app_transfers[type].getActiveObjects();
  else
    return _between_multi_app_transfers[type].getActiveObjects();
}

getTransfers() [2/2]

std::vector< std::shared_ptr< Transfer > > FEProblemBase::getTransfers ( Transfer::DIRECTION  direction ) const

inherited

Definition at line 5616 of file FEProblemBase.C.

{
  if (direction == MultiAppTransfer::TO_MULTIAPP)
    return _to_multi_app_transfers.getActiveObjects();
  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
    return _from_multi_app_transfers.getActiveObjects();
  else
    return _between_multi_app_transfers.getActiveObjects();
}

getUserObject()

template<class T >

T& FEProblemBase::getUserObject ( const std::string &  name, unsigned int  tid = 0  ) const

inlineinherited

Get the user object by its name.

Parameters

name	The name of the user object being retrieved

Returns

Const reference to the user object

Definition at line 1284 of file FEProblemBase.h.

Referenced by ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), ReporterTransferInterface::hideVariableHelper(), EigenExecutionerBase::init(), Eigenvalue::init(), IntegralPreservingFunctionIC::initialSetup(), ElementSubdomainModifierBase::initialSetup(), and EigenExecutionerBase::inversePowerIteration().

  {
    std::vector<T *> objs;
    theWarehouse()
        .query()
        .condition<AttribSystem>("UserObject")
        .condition<AttribThread>(tid)
        .condition<AttribName>(name)
        .queryInto(objs);
    if (objs.empty())
      mooseError("Unable to find user object with name '" + name + "'");
    return *(objs[0]);
  }

getUserObjectBase()

const UserObject & FEProblemBase::getUserObjectBase ( const std::string &  name, const THREAD_ID  tid = 0  ) const

inherited

Get the user object by its name.

Parameters

name	The name of the user object being retrieved
tid	The thread of the user object (defaults to 0)

Returns

Const reference to the user object

Definition at line 4584 of file FEProblemBase.C.

Referenced by addBoundaryCondition(), addKernel(), FEProblemBase::addPostprocessor(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiApp::appUserObjectBase(), EigenProblem::checkProblemIntegrity(), FunctorAux::computeValue(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectFromFEProblem(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppConservativeTransfer::initialSetup(), Terminator::initialSetup(), and FunctorIC::value().

{
  std::vector<UserObject *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>("UserObject")
      .condition<AttribThread>(tid)
      .condition<AttribName>(name)
      .queryInto(objs);
  if (objs.empty())
    mooseError("Unable to find user object with name '" + name + "'");
  mooseAssert(objs.size() == 1, "Should only find one UO");
  return *(objs[0]);
}

getUserObjectJacobianVariables()

const std::vector<const MooseVariableFEBase *>& FEProblemBase::getUserObjectJacobianVariables ( const THREAD_ID  tid ) const

inlineinherited

Definition at line 324 of file FEProblemBase.h.

Referenced by ComputeUserObjectsThread::onBoundary(), and ComputeUserObjectsThread::onElement().

  {
    return _uo_jacobian_moose_vars[tid];
  }

getUserObjects()

const ExecuteMooseObjectWarehouse<UserObject>& FEProblemBase::getUserObjects ( ) const

inlineinherited

Definition at line 1271 of file FEProblemBase.h.

  {
    mooseDeprecated(
        "This function is deprecated, use theWarehouse().query() to construct a query instead");
    return _all_user_objects;
  }

getVariable() [1/4]

virtual const MooseVariableFieldBase& SubProblem::getVariable

inherited

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.

getVariable() [2/4]

virtual MooseVariableFieldBase& SubProblem::getVariable

inlineinherited

Definition at line 279 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() [3/4]

const MooseVariableFieldBase & FEProblemBase::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

overridevirtualinherited

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.

Implements SubProblem.

Definition at line 5916 of file FEProblemBase.C.

Referenced by FEProblemBase::addFVInitialCondition(), FEProblemBase::addInitialCondition(), EigenProblem::adjustEigenVector(), MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldShapeEvaluationTransfer::buildMeshFunctions(), CoupleableMooseVariableDependencyIntermediateInterface::coupledArrayValueByName(), CoupleableMooseVariableDependencyIntermediateInterface::coupledValueByName(), NodalNormalsCorner::execute(), NodalNormalsEvaluator::execute(), MultiAppProjectionTransfer::execute(), NodalNormalsPreprocessor::execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), LazyCoupleable::init(), AdvancedOutput::initAvailableLists(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppProjectionTransfer::initialSetup(), AdvancedOutput::initShowHideLists(), SolutionUserObjectBase::pointValueWrapper(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), MultiAppProjectionTransfer::projectSolution(), MultiAppDofCopyTransfer::transfer(), and MultiAppShapeEvaluationTransfer::transferVariable().

{
  return getVariableHelper(
      tid, var_name, expected_var_type, expected_var_field_type, _solver_systems, *_aux);
}

getVariable() [4/4]

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  )

inlinevirtualinherited

Definition at line 279 of file SubProblem.h.

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

getVariableHelper() [1/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

inherited

Definition at line 819 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?");
  }
}

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

protectedinherited

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

getVariableNames()

std::vector< VariableName > FEProblemBase::getVariableNames ( )

virtualinherited

Returns a list of all the variables in the problem (both from the NL and Aux systems.

Definition at line 8891 of file FEProblemBase.C.

Referenced by EigenProblem::adjustEigenVector(), AdvancedOutput::initAvailableLists(), and ElementSubdomainModifierBase::initialSetup().

{
  std::vector<VariableName> names;

  for (auto & sys : _solver_systems)
  {
    const std::vector<VariableName> & var_names = sys->getVariableNames();
    names.insert(names.end(), var_names.begin(), var_names.end());
  }

  const std::vector<VariableName> & aux_var_names = _aux->getVariableNames();
  names.insert(names.end(), aux_var_names.begin(), aux_var_names.end());

  return names;
}

getVectorPostprocessorObjectByName()

const VectorPostprocessor & FEProblemBase::getVectorPostprocessorObjectByName ( const std::string &  object_name, const THREAD_ID  tid = 0  ) const

inherited

Return the VPP object given the name.

Parameters

object_name

The name of the VPP object

Returns

Desired VPP object

This is used by various output objects as well as the scatter value handling.

See also

CSV.C, XMLOutput.C, VectorPostprocessorInterface.C

Definition at line 4678 of file FEProblemBase.C.

Referenced by VectorPostprocessorInterface::isVectorPostprocessorDistributedByName(), CSV::output(), and XMLOutput::outputVectorPostprocessors().

{
  return getUserObject<VectorPostprocessor>(object_name, tid);
}

getVectorPostprocessorValueByName()

const VectorPostprocessorValue & FEProblemBase::getVectorPostprocessorValueByName ( const std::string &  object_name, const std::string &  vector_name, std::size_t  t_index = 0  ) const

inherited

Get a read-only reference to the vector value associated with the VectorPostprocessor.

Parameters

object_name	The name of the VPP object.
vector_name	The namve of the decalred vector within the object.

Returns

Referent to the vector of data.

Note: This method is only for retrieving values that already exist, the VectorPostprocessor and VectorPostprocessorInterface objects should be used rather than this method for creating and getting values within objects.

Definition at line 4659 of file FEProblemBase.C.

Referenced by HistogramVectorPostprocessor::execute().

{
  return _reporter_data.getReporterValue<VectorPostprocessorValue>(
      VectorPostprocessorReporterName(object_name, vector_name), t_index);
}

getVectorTag()

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

virtualinherited

Get a VectorTag from a TagID.

Reimplemented in DisplacedProblem.

Definition at line 162 of file SubProblem.C.

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

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

getVectorTagID()

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

virtualinherited

Get a TagID from a TagName.

Reimplemented in DisplacedProblem.

Definition at line 204 of file SubProblem.C.

Referenced by Coupleable::coupledVectorTagArrayGradient(), Coupleable::coupledVectorTagArrayGradients(), Coupleable::coupledVectorTagArrayValues(), Coupleable::coupledVectorTagDofValues(), Coupleable::coupledVectorTagGradient(), Coupleable::coupledVectorTagGradients(), 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().

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

getVectorTags() [1/2]

std::vector< VectorTag > SubProblem::getVectorTags ( const std::set< TagID > &  tag_ids ) const

inherited

Definition at line 173 of file SubProblem.C.

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

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

getVectorTags() [2/2]

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

virtualinherited

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 185 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];
}

getVectorVariable()

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

overridevirtualinherited

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

Implements SubProblem.

Definition at line 5950 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    if (sys->hasVariable(var_name))
      return sys->getFieldVariable<RealVectorValue>(tid, var_name);
  if (_aux->hasVariable(var_name))
    return _aux->getFieldVariable<RealVectorValue>(tid, var_name);

  mooseError("Unknown variable " + var_name);
}

getXFEM()

std::shared_ptr<XFEMInterface> FEProblemBase::getXFEM ( )

inlineinherited

Get a pointer to the XFEM controller object.

Definition at line 1933 of file FEProblemBase.h.

{ return _xfem; }

ghostedElems()

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

inlinevirtualinherited

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

Returns

The list

Reimplemented in DisplacedProblem.

Definition at line 672 of file SubProblem.h.

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

{ return _ghosted_elems; }

ghostGhostedBoundaries()

void FEProblemBase::ghostGhostedBoundaries ( )

overridevirtualinherited

Causes the boundaries added using addGhostedBoundary to actually be ghosted.

Implements SubProblem.

Definition at line 2147 of file FEProblemBase.C.

Referenced by DisplacedProblem::ghostGhostedBoundaries(), FEProblemBase::init(), and FEProblemBase::meshChanged().

{
  TIME_SECTION("ghostGhostedBoundaries", 3, "Ghosting Ghosted Boundaries");

  _mesh.ghostGhostedBoundaries();

  if (_displaced_problem)
    _displaced_mesh->ghostGhostedBoundaries();
}

hasActiveElementalMooseVariables()

bool SubProblem::hasActiveElementalMooseVariables ( const THREAD_ID  tid ) const

virtualinherited

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 461 of file SubProblem.C.

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

{
  return _has_active_elemental_moose_variables[tid];
}

hasActiveMaterialProperties()

bool FEProblemBase::hasActiveMaterialProperties ( const THREAD_ID  tid ) const

inherited

Method to check whether or not a list of active material roperties has been set.

This method is called by reinitMaterials to determine whether Material computeProperties methods need to be called. If the return is False, this check prevents unnecessary material property computation

Parameters

tid	The thread id

Returns

True if there has been a list of active material properties set, False otherwise

Definition at line 6124 of file FEProblemBase.C.

Referenced by ComputeMarkerThread::onElement(), FEProblemBase::reinitMaterials(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsInterface(), FEProblemBase::reinitMaterialsNeighbor(), and FEProblemBase::reinitMaterialsNeighborOnBoundary().

{
  return _has_active_material_properties[tid];
}

hasAuxiliaryVariable()

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

virtualinherited

Whether or not this problem has this auxiliary variable.

Definition at line 812 of file SubProblem.C.

Referenced by SubProblem::getFunctor(), and NearestNodeValueAux::NearestNodeValueAux().

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

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  )

virtualinherited

Check if a material property is defined on a block.

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

virtualinherited

Check if a material property is defined on a block.

Definition at line 571 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;
}

hasConvergence()

bool FEProblemBase::hasConvergence ( const std::string &  name, const THREAD_ID  tid = 0  ) const

virtualinherited

Returns true if the problem has a Convergence object of the given name.

Definition at line 2667 of file FEProblemBase.C.

Referenced by ParsedConvergence::initializeSymbols().

{
  return _convergences.hasActiveObject(name, tid);
}

hasDampers()

bool FEProblemBase::hasDampers ( )

inlineinherited

Whether or not this system has dampers.

Definition at line 1421 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::preInit(), and NonlinearSystem::solve().

{ return _has_dampers; }

hasException()

virtual bool FEProblemBase::hasException ( )

inlinevirtualinherited

Whether or not an exception has occurred.

Definition at line 502 of file FEProblemBase.h.

Referenced by NonlinearSystem::converged(), ThreadedElementLoop< ConstElemPointerRange >::keepGoing(), and ThreadedNodeLoop< ConstBndNodeRange, ConstBndNodeRange::const_iterator >::keepGoing().

{ return _has_exception; }

hasFunction()

bool FEProblemBase::hasFunction ( const std::string &  name, const THREAD_ID  tid = 0  )

virtualinherited

Definition at line 2616 of file FEProblemBase.C.

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), FunctorIC::FunctorIC(), FEProblemBase::getFunction(), FunctionInterface::hasFunctionByName(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), ParsedConvergence::initializeSymbols(), and MooseParsedFunction::initialSetup().

{
  return _functions.hasActiveObject(name, tid);
}

hasFunctor()

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

inherited

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

Definition at line 1275 of file SubProblem.C.

Referenced by FunctorInterface::isFunctor().

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

hasFunctorWithType()

template<typename T >

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

inherited

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

Definition at line 1325 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());
}

hasInitialAdaptivity() [1/2]

bool FEProblemBase::hasInitialAdaptivity ( ) const

inlineinherited

Return a Boolean indicating whether initial AMR is turned on.

Definition at line 1921 of file FEProblemBase.h.

{ return _adaptivity.getInitialSteps() > 0; }

hasInitialAdaptivity() [2/2]

bool FEProblemBase::hasInitialAdaptivity ( ) const

inlineinherited

Return a Boolean indicating whether initial AMR is turned on.

Definition at line 1926 of file FEProblemBase.h.

{ return false; }

hasJacobian()

bool FEProblemBase::hasJacobian ( ) const

inherited

Returns _has_jacobian.

Definition at line 9054 of file FEProblemBase.C.

{
  return _has_jacobian;
}

hasKokkosObjects()

bool FEProblemBase::hasKokkosObjects ( ) const

inlineinherited

Returns

whether any Kokkos object was added in the problem

Definition at line 2718 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::preInit(), and MooseMesh::update().

{ return _has_kokkos_objects; }

hasKokkosResidualObjects()

bool FEProblemBase::hasKokkosResidualObjects ( ) const

inlineinherited

Returns

whether any Kokkos residual object was added in the problem

Definition at line 2722 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::computeJacobianInternal(), and NonlinearSystemBase::computeResidualInternal().

{ return _has_kokkos_residual_objects; }

hasLinearConvergenceObjects()

bool FEProblemBase::hasLinearConvergenceObjects ( ) const

inherited

Whether we have linear convergence objects.

Definition at line 9393 of file FEProblemBase.C.

Referenced by Moose::PetscSupport::petscSetDefaults().

{
  // If false,this means we have not set one, not that we are querying this too early
  // TODO: once there is a default linear CV object, error on the 'not set' case
  return _linear_convergence_names.has_value();
}

hasLinearVariable()

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

virtualinherited

Whether or not this problem has this linear variable.

Definition at line 803 of file SubProblem.C.

Referenced by SubProblem::getFunctor().

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

hasMortarCoupling()

virtual bool FEProblemBase::hasMortarCoupling ( ) const

inlinevirtualinherited

Whether the simulation has mortar coupling.

Definition at line 2418 of file FEProblemBase.h.

{ return _has_mortar; }

hasMultiApp()

bool FEProblemBase::hasMultiApp ( const std::string &  name ) const

inherited

Definition at line 5526 of file FEProblemBase.C.

{
  return _multi_apps.hasActiveObject(multi_app_name);
}

hasMultiApps() [1/2]

bool FEProblemBase::hasMultiApps ( ) const

inlineinherited

Returns whether or not the current simulation has any multiapps.

Definition at line 1407 of file FEProblemBase.h.

Referenced by DefaultMultiAppFixedPointConvergence::checkConvergence(), FEProblemBase::checkProblemIntegrity(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), FixedPointIterationAdaptiveDT::init(), and DefaultMultiAppFixedPointConvergence::preExecute().

{ return _multi_apps.hasActiveObjects(); }

hasMultiApps() [2/2]

bool FEProblemBase::hasMultiApps ( ExecFlagType  type ) const

inherited

Definition at line 5520 of file FEProblemBase.C.

{
  return _multi_apps[type].hasActiveObjects();
}

hasNeighborCoupling()

virtual bool FEProblemBase::hasNeighborCoupling ( ) const

inlinevirtualinherited

Whether the simulation has neighbor coupling.

Definition at line 2413 of file FEProblemBase.h.

{ return _has_internal_edge_residual_objects; }

hasNonlocalCoupling()

virtual bool FEProblemBase::hasNonlocalCoupling ( ) const

inlineoverridevirtualinherited

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

Implements SubProblem.

Definition at line 2675 of file FEProblemBase.h.

Referenced by DisplacedProblem::hasNonlocalCoupling().

{ return _has_nonlocal_coupling; }

hasPostprocessor()

bool FEProblemBase::hasPostprocessor ( const std::string &  name ) const

inherited

Deprecated.

Use hasPostprocessorValueByName

Definition at line 4651 of file FEProblemBase.C.

Referenced by GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl().

{
  mooseDeprecated("FEProblemBase::hasPostprocssor is being removed; use "
                  "hasPostprocessorValueByName instead.");
  return hasPostprocessorValueByName(name);
}

hasPostprocessorValueByName()

bool FEProblemBase::hasPostprocessorValueByName ( const PostprocessorName &  name ) const

inherited

Whether or not a Postprocessor value exists by a given name.

Parameters

name	The name of the Postprocessor

Returns

True if a Postprocessor value exists

Note: You should prioritize the use of PostprocessorInterface::hasPostprocessor and PostprocessorInterface::hasPostprocessorByName over this method when possible.

Definition at line 4628 of file FEProblemBase.C.

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), FunctorAux::computeValue(), FunctorExtremaPositions::FunctorExtremaPositions(), FEProblemBase::hasPostprocessor(), MooseParsedFunction::initialSetup(), and FunctorIC::value().

{
  return _reporter_data.hasReporterValue<PostprocessorValue>(PostprocessorReporterName(name));
}

hasScalarVariable()

bool FEProblemBase::hasScalarVariable ( const std::string &  var_name ) const

overridevirtualinherited

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

Implements SubProblem.

Definition at line 5974 of file FEProblemBase.C.

Referenced by FEProblemBase::addInitialCondition(), FEProblemBase::addObjectParamsHelper(), EigenProblem::adjustEigenVector(), FEProblemBase::checkDuplicatePostprocessorVariableNames(), AdvancedOutput::initAvailableLists(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), AdvancedOutput::initShowHideLists(), and Split::setup().

{
  for (auto & sys : _solver_systems)
    if (sys->hasScalarVariable(var_name))
      return true;
  if (_aux->hasScalarVariable(var_name))
    return true;

  return false;
}

hasScalingVector()

void SubProblem::hasScalingVector ( const unsigned int  nl_sys_num )

inherited

Tells this problem that the assembly associated with the given nonlinear system number involves a scaling vector.

Definition at line 1171 of file SubProblem.C.

Referenced by SystemBase::addScalingVector().

{
  for (const THREAD_ID tid : make_range(libMesh::n_threads()))
    assembly(tid, nl_sys_num).hasScalingVector();
}

hasSetMultiAppFixedPointConvergenceName()

bool FEProblemBase::hasSetMultiAppFixedPointConvergenceName ( ) const

inlineinherited

Returns true if the problem has set the fixed point convergence name.

Definition at line 694 of file FEProblemBase.h.

  {
    return _multiapp_fixed_point_convergence_name.has_value();
  }

hasSetSteadyStateConvergenceName()

bool FEProblemBase::hasSetSteadyStateConvergenceName ( ) const

inlineinherited

Returns true if the problem has set the steady-state detection convergence name.

Definition at line 699 of file FEProblemBase.h.

  {
    return _steady_state_convergence_name.has_value();
  }

hasSolverVariable()

bool FEProblemBase::hasSolverVariable ( const std::string &  var_name ) const

inherited

Definition at line 5906 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    if (sys->hasVariable(var_name))
      return true;

  return false;
}

hasTimeIntegrator()

bool FEProblemBase::hasTimeIntegrator ( ) const

inlineinherited

Returns whether or not this Problem has a TimeIntegrator.

Definition at line 2204 of file FEProblemBase.h.

Referenced by TransientBase::setupTimeIntegrator().

{ return _has_time_integrator; }

hasUOAuxStateCheck()

bool FEProblemBase::hasUOAuxStateCheck ( ) const

inlineinherited

Whether or not MOOSE will perform a user object/auxiliary kernel state check.

Definition at line 201 of file FEProblemBase.h.

{ return _uo_aux_state_check; }

hasUserObject()

bool FEProblemBase::hasUserObject ( const std::string &  name ) const

inherited

Check if there if a user object of given name.

Parameters

name	The name of the user object being checked for

Returns

true if the user object exists, false otherwise

Definition at line 4615 of file FEProblemBase.C.

Referenced by addMFEMFESpaceFromMOOSEVariable(), FEProblemBase::addPostprocessor(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), FunctorAux::computeValue(), DistributedPositions::DistributedPositions(), UserObjectInterface::hasUserObjectByName(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), ReporterTransferInterface::hideVariableHelper(), ParsedDownSelectionPositions::initialize(), and TransformedPositions::TransformedPositions().

{
  std::vector<UserObject *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>("UserObject")
      .condition<AttribThread>(0)
      .condition<AttribName>(name)
      .queryInto(objs);
  return !objs.empty();
}

hasVariable()

bool FEProblemBase::hasVariable ( const std::string &  var_name ) const

overridevirtualinherited

Whether or not this problem has the variable.

Implements SubProblem.

Definition at line 5894 of file FEProblemBase.C.

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), FEProblemBase::addFVInitialCondition(), DiffusionFV::addFVKernels(), FEProblemBase::addInitialCondition(), FEProblemBase::addObjectParamsHelper(), MultiAppTransfer::checkVariable(), FunctorIC::FunctorIC(), LazyCoupleable::init(), AdvancedOutput::initAvailableLists(), MooseParsedFunction::initialSetup(), AdvancedOutput::initShowHideLists(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), and Split::setup().

{
  for (auto & sys : _solver_systems)
    if (sys->hasVariable(var_name))
      return true;
  if (_aux->hasVariable(var_name))
    return true;

  return false;
}

haveADObjects() [1/4]

bool SubProblem::haveADObjects ( ) const

inlineinherited

Method for reading wehther we have any ad objects.

Definition at line 771 of file SubProblem.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::init().

{ return _have_ad_objects; }

haveADObjects() [2/4]

virtual void SubProblem::haveADObjects

inlineinherited

Method for setting whether we have any ad objects.

Definition at line 767 of file SubProblem.h.

{ _have_ad_objects = have_ad_objects; }

haveADObjects() [3/4]

bool SubProblem::haveADObjects

inlineinherited

Method for reading wehther we have any ad objects.

Definition at line 771 of file SubProblem.h.

{ return _have_ad_objects; }

haveADObjects() [4/4]

void FEProblemBase::haveADObjects ( bool  have_ad_objects )

overridevirtualinherited

Method for setting whether we have any ad objects.

Reimplemented from SubProblem.

Definition at line 9131 of file FEProblemBase.C.

{
  _have_ad_objects = have_ad_objects;
  if (_displaced_problem)
    _displaced_problem->SubProblem::haveADObjects(have_ad_objects);
}

haveDisplaced()

bool FEProblemBase::haveDisplaced ( ) const

inlinefinaloverridevirtualinherited

Whether we have a displaced problem in our simulation.

Implements SubProblem.

Definition at line 2509 of file FEProblemBase.h.

{ return _displaced_problem.get(); }

haveFV()

virtual bool FEProblemBase::haveFV ( ) const

inlineoverridevirtualinherited

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

Implements SubProblem.

Definition at line 2673 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::checkKernelCoverage(), NonlinearSystemBase::computeJacobianInternal(), ComputeFullJacobianThread::computeOnElement(), NonlinearThread::computeOnElement(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::customSetup(), ComputeResidualThread::determineObjectWarehouses(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), DisplacedProblem::haveFV(), FEProblemBase::init(), NonlinearSystemBase::initialSetup(), FEProblemBase::meshChanged(), FEProblemBase::projectSolution(), NonlinearThread::subdomainChanged(), FEProblemBase::swapBackMaterialsNeighbor(), and NonlinearSystemBase::timestepSetup().

{ return _have_fv; }

havePRefinement()

bool SubProblem::havePRefinement ( ) const

inlineinherited

Query whether p-refinement has been requested at any point during the simulation.

Definition at line 1011 of file SubProblem.h.

Referenced by AdvancedOutput::initAvailableLists(), and FEProblemBase::meshChanged().

{ return _have_p_refinement; }

haveXFEM()

bool FEProblemBase::haveXFEM ( )

inlineinherited

Find out whether the current analysis is using XFEM.

Definition at line 1936 of file FEProblemBase.h.

Referenced by FEProblemBase::initialSetup(), FixedPointSolve::solveStep(), TransientBase::takeStep(), and FEProblemBase::updateMeshXFEM().

{ return _xfem != nullptr; }

identifyVariableGroupsInNL()

bool FEProblemBase::identifyVariableGroupsInNL ( ) const

inlineinherited

Whether to identify variable groups in nonlinear systems.

This affects dof ordering

Definition at line 2680 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::NonlinearSystemBase().

{ return _identify_variable_groups_in_nl; }

ignoreZerosInJacobian()

bool FEProblemBase::ignoreZerosInJacobian ( ) const

inlineinherited

Will return true if zeros in the Jacobian are to be dropped from the sparsity pattern.

Note that this can make preserving the matrix sparsity pattern impossible.

Definition at line 2176 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), and NonlinearSystemBase::constraintJacobians().

{ return _ignore_zeros_in_jacobian; }

immediatelyPrintInvalidSolution()

bool FEProblemBase::immediatelyPrintInvalidSolution ( ) const

inlineinherited

Whether or not the solution invalid warnings are printed out immediately.

Definition at line 2201 of file FEProblemBase.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

{ return _immediately_print_invalid_solution; }

incrementMultiAppTStep()

void FEProblemBase::incrementMultiAppTStep ( ExecFlagType  type )

inherited

Advance the MultiApps t_step (incrementStepOrReject) associated with the ExecFlagType.

Definition at line 5711 of file FEProblemBase.C.

Referenced by TransientBase::incrementStepOrReject().

{
  const auto & multi_apps = _multi_apps[type].getActiveObjects();

  if (multi_apps.size())
    for (const auto & multi_app : multi_apps)
      multi_app->incrementTStep(_time);
}

init()

void FEProblemBase::init ( )

overridevirtualinherited

Implements Problem.

Reimplemented in FEProblem, and EigenProblem.

Definition at line 6398 of file FEProblemBase.C.

Referenced by EigenProblem::init(), and FEProblem::init().

{
  if (_initialized)
    return;

  TIME_SECTION("init", 2, "Initializing");

  // call executioner's preProblemInit so that it can do some setups before problem init
  _app.getExecutioner()->preProblemInit();

  // If we have AD and we are doing global AD indexing, then we should by default set the matrix
  // coupling to full. If the user has told us to trust their coupling matrix, then this call will
  // not do anything
  if (haveADObjects() && Moose::globalADIndexing())
    setCoupling(Moose::COUPLING_FULL);

  for (const auto i : index_range(_nl))
  {
    auto & nl = _nl[i];
    auto & cm = _cm[i];

    unsigned int n_vars = nl->nVariables();
    {
      TIME_SECTION("fillCouplingMatrix", 3, "Filling Coupling Matrix");

      switch (_coupling)
      {
        case Moose::COUPLING_DIAG:
          cm = std::make_unique<CouplingMatrix>(n_vars);
          for (unsigned int i = 0; i < n_vars; i++)
            (*cm)(i, i) = 1;
          break;

          // for full jacobian
        case Moose::COUPLING_FULL:
          cm = std::make_unique<CouplingMatrix>(n_vars);
          for (unsigned int i = 0; i < n_vars; i++)
            for (unsigned int j = 0; j < n_vars; j++)
              (*cm)(i, j) = 1;
          break;

        case Moose::COUPLING_CUSTOM:
          // do nothing, _cm was already set through couplingMatrix() call
          break;
      }
    }

    nl->dofMap()._dof_coupling = cm.get();

    // If there are no variables, make sure to pass a nullptr coupling
    // matrix, to avoid warnings about non-nullptr yet empty
    // CouplingMatrices.
    if (n_vars == 0)
      nl->dofMap()._dof_coupling = nullptr;

    nl->dofMap().attach_extra_sparsity_function(&extraSparsity, nl.get());
    nl->dofMap().attach_extra_send_list_function(&extraSendList, nl.get());
    _aux->dofMap().attach_extra_send_list_function(&extraSendList, _aux.get());

    if (!_skip_nl_system_check && _solve && n_vars == 0)
      mooseError("No variables specified in nonlinear system '", nl->name(), "'.");
  }

  ghostGhostedBoundaries(); // We do this again right here in case new boundaries have been added

  // We may have added element/nodes to the mesh in ghostGhostedBoundaries so we need to update
  // all of our mesh information. We need to make sure that mesh information is up-to-date before
  // EquationSystems::init because that will call through to updateGeomSearch (for sparsity
  // augmentation) and if we haven't added back boundary node information before that latter call,
  // then we're screwed. We'll get things like "Unable to find closest node!"
  _mesh.meshChanged();
  if (_displaced_problem)
    _displaced_mesh->meshChanged();

  if (_mesh.doingPRefinement())
  {
    preparePRefinement();
    if (_displaced_problem)
      _displaced_problem->preparePRefinement();
  }

  // do not assemble system matrix for JFNK solve
  for (auto & nl : _nl)
    if (solverParams(nl->number())._type == Moose::ST_JFNK)
      nl->turnOffJacobian();

  for (auto & sys : _solver_systems)
    sys->preInit();
  _aux->preInit();

  // Build the mortar segment meshes, if they haven't been already, for a couple reasons:
  // 1) Get the ghosting correct for both static and dynamic meshes
  // 2) Make sure the mortar mesh is built for mortar constraints that live on the static mesh
  //
  // It is worth-while to note that mortar meshes that live on a dynamic mesh will be built
  // during residual and Jacobian evaluation because when displacements are solution variables
  // the mortar mesh will move and change during the course of a non-linear solve. We DO NOT
  // redo ghosting during non-linear solve, so for purpose 1) the below call has to be made
  if (!_mortar_data->initialized())
    updateMortarMesh();

  {
    TIME_SECTION("EquationSystems::Init", 2, "Initializing Equation Systems");
    es().init();
  }

  for (auto & sys : _solver_systems)
    sys->postInit();
  _aux->postInit();

  // Now that the equation system and the dof distribution is done, we can generate the
  // finite volume-related parts if needed.
  if (haveFV())
    _mesh.setupFiniteVolumeMeshData();

  for (auto & sys : _solver_systems)
    sys->update();
  _aux->update();

  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
    for (const auto i : index_range(_nl))
    {
      mooseAssert(
          _cm[i],
          "Coupling matrix not set for system "
              << i
              << ". This should only happen if a preconditioner was not setup for this system");
      _assembly[tid][i]->init(_cm[i].get());
    }

  if (_displaced_problem)
    _displaced_problem->init();

#ifdef MOOSE_KOKKOS_ENABLED
  if (_has_kokkos_objects)
    initKokkos();
#endif

  _initialized = true;
}

initElementStatefulProps()

void FEProblemBase::initElementStatefulProps ( const libMesh::ConstElemRange &  elem_range, const bool  threaded  )

inherited

Initialize stateful properties for elements in a specific elem_range This is needed when elements/boundary nodes are added to a specific subdomain at an intermediate step.

Definition at line 8485 of file FEProblemBase.C.

Referenced by ActivateElementsUserObjectBase::finalize(), ElementSubdomainModifierBase::initElementStatefulProps(), and FEProblemBase::initialSetup().

{
  ComputeMaterialsObjectThread cmt(
      *this, _material_props, _bnd_material_props, _neighbor_material_props, _assembly);
  if (threaded)
    Threads::parallel_reduce(elem_range, cmt);
  else
    cmt(elem_range, true);

#ifdef MOOSE_KOKKOS_ENABLED
  if (_has_kokkos_objects)
    initKokkosStatefulProps();
#endif
}

initialAdaptMesh()

void FEProblemBase::initialAdaptMesh ( )

virtualinherited

Definition at line 8155 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

{
  unsigned int n = adaptivity().getInitialSteps();
  _cycles_completed = 0;
  if (n)
  {
    if (!_mesh.interiorLowerDBlocks().empty() || !_mesh.boundaryLowerDBlocks().empty())
      mooseError("HFEM does not support mesh adaptivity currently.");

    TIME_SECTION("initialAdaptMesh", 2, "Performing Initial Adaptivity");

    for (unsigned int i = 0; i < n; i++)
    {
      computeIndicators();
      computeMarkers();

      if (_adaptivity.initialAdaptMesh())
      {
        meshChanged(
            /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);

        // reproject the initial condition
        projectSolution();

        _cycles_completed++;
      }
      else
      {
        _console << "Mesh unchanged, skipping remaining steps..." << std::endl;
        return;
      }
    }
  }
}

initialSetup()

void MFEMProblem::initialSetup ( )

overridevirtual

Reimplemented from SubProblem.

Definition at line 43 of file MFEMProblem.C.

Referenced by MFEMSteady::init().

{
  FEProblemBase::initialSetup();
  addMFEMNonlinearSolver();
}

initKokkos()

void FEProblemBase::initKokkos ( )

inherited

Construct Kokkos assembly and systems and allocate Kokkos material property storages.

Referenced by FEProblemBase::init().

initKokkosStatefulProps()

void FEProblemBase::initKokkosStatefulProps ( )

inherited

Referenced by FEProblemBase::initElementStatefulProps().

initNullSpaceVectors()

void FEProblemBase::initNullSpaceVectors ( const InputParameters &  parameters, std::vector< std::shared_ptr< NonlinearSystemBase >> &  nl  )

virtualinherited

Definition at line 760 of file FEProblemBase.C.

Referenced by EigenProblem::EigenProblem(), and FEProblem::FEProblem().

{
  TIME_SECTION("initNullSpaceVectors", 5, "Initializing Null Space Vectors");

  unsigned int dimNullSpace = parameters.get<unsigned int>("null_space_dimension");
  unsigned int dimTransposeNullSpace =
      parameters.get<unsigned int>("transpose_null_space_dimension");
  unsigned int dimNearNullSpace = parameters.get<unsigned int>("near_null_space_dimension");
  for (unsigned int i = 0; i < dimNullSpace; ++i)
  {
    std::ostringstream oss;
    oss << "_" << i;
    // do not project, since this will be recomputed, but make it ghosted, since the near nullspace
    // builder might march over all nodes
    for (auto & nl : nls)
      nl->addVector("NullSpace" + oss.str(), false, libMesh::GHOSTED);
  }
  _subspace_dim["NullSpace"] = dimNullSpace;
  for (unsigned int i = 0; i < dimTransposeNullSpace; ++i)
  {
    std::ostringstream oss;
    oss << "_" << i;
    // do not project, since this will be recomputed, but make it ghosted, since the near nullspace
    // builder might march over all nodes
    for (auto & nl : nls)
      nl->addVector("TransposeNullSpace" + oss.str(), false, libMesh::GHOSTED);
  }
  _subspace_dim["TransposeNullSpace"] = dimTransposeNullSpace;
  for (unsigned int i = 0; i < dimNearNullSpace; ++i)
  {
    std::ostringstream oss;
    oss << "_" << i;
    // do not project, since this will be recomputed, but make it ghosted, since the near-nullspace
    // builder might march over all semilocal nodes
    for (auto & nl : nls)
      nl->addVector("NearNullSpace" + oss.str(), false, libMesh::GHOSTED);
  }
  _subspace_dim["NearNullSpace"] = dimNearNullSpace;
}

initPetscOutputAndSomeSolverSettings()

void FEProblemBase::initPetscOutputAndSomeSolverSettings ( )

virtualinherited

Reinitialize PETSc output for proper linear/nonlinear iteration display.

This also may be used for some PETSc-related solver settings

Reimplemented in EigenProblem.

Definition at line 6957 of file FEProblemBase.C.

Referenced by FEProblemBase::possiblyRebuildGeomSearchPatches(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), and FEProblemBase::solve().

{
  _app.getOutputWarehouse().solveSetup();
  Moose::PetscSupport::petscSetDefaults(*this);
}

initXFEM()

void FEProblemBase::initXFEM ( std::shared_ptr< XFEMInterface >  xfem )

inherited

Create XFEM controller object.

Definition at line 8253 of file FEProblemBase.C.

{
  _xfem = xfem;
  _xfem->setMesh(&_mesh);
  if (_displaced_mesh)
    _xfem->setDisplacedMesh(_displaced_mesh);

  auto fill_data = [](auto & storage)
  {
    std::vector<MaterialData *> data(libMesh::n_threads());
    for (const auto tid : make_range(libMesh::n_threads()))
      data[tid] = &storage.getMaterialData(tid);
    return data;
  };
  _xfem->setMaterialData(fill_data(_material_props));
  _xfem->setBoundaryMaterialData(fill_data(_bnd_material_props));

  unsigned int n_threads = libMesh::n_threads();
  for (unsigned int i = 0; i < n_threads; ++i)
    for (const auto nl_sys_num : index_range(_nl))
    {
      _assembly[i][nl_sys_num]->setXFEM(_xfem);
      if (_displaced_problem)
        _displaced_problem->assembly(i, nl_sys_num).setXFEM(_xfem);
    }
}

isKokkosObject()

bool MooseObject::isKokkosObject ( IsKokkosObjectKey &&  ) const

inlineinherited

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

• Moose::Kokkos::ResidualObject in KokkosResidualObject.K
• Moose::Kokkos::MaterialBase in KokkosMaterialBase.K

Definition at line 75 of file MooseObject.h.

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

  {
    return parameters().isParamValid(MooseBase::kokkos_object_param);
  }

isMatPropRequested()

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

virtualinherited

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

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

Referenced by SetupDebugAction::act(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), MFEMMesh::buildMesh(), MFEMDomainSubMesh::buildSubMesh(), MFEMBoundarySubMesh::buildSubMesh(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PiecewiseTabularBase::PiecewiseTabularBase(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::runInputFile(), MooseApp::runInputs(), MFEMSolverBase::setPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), and XYDelaunayGenerator::XYDelaunayGenerator().

  {
    return _pars.isParamSetByUser(name);
  }

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.

Referenced by HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), CopyNodalVarsAction::act(), SetupMeshAction::act(), SetupDebugAction::act(), ComposeTimeStepperAction::act(), SetAdaptivityOptionsAction::act(), AddVariableAction::act(), CreateDisplacedProblemAction::act(), CommonOutputAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AddPeriodicBCAction::AddPeriodicBCAction(), DiffusionPhysicsBase::addPostprocessors(), AdvectiveFluxAux::AdvectiveFluxAux(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayVarReductionAux::ArrayVarReductionAux(), AddPeriodicBCAction::autoTranslationBoundaries(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), TimedSubdomainModifier::buildFromFile(), PiecewiseTabularBase::buildFromFile(), PiecewiseTabularBase::buildFromJSON(), ParsedChainControl::buildFunction(), GeneratedMesh::buildMesh(), MooseMesh::buildTypedMesh(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), LibmeshPartitioner::clone(), SampledOutput::cloneMesh(), CombinerGenerator::CombinerGenerator(), FunctorAux::computeValue(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), FEProblemSolve::convergenceSetup(), CopyMeshPartitioner::CopyMeshPartitioner(), CSVReaderVectorPostprocessor::CSVReaderVectorPostprocessor(), CutMeshByLevelSetGeneratorBase::CutMeshByLevelSetGeneratorBase(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), DGKernelBase::DGKernelBase(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), Eigenvalue::Eigenvalue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), PIDTransientControl::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), Exodus::Exodus(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), FunctionDT::FunctionDT(), FunctionValuePostprocessor::FunctionValuePostprocessor(), FVInterfaceKernel::FVInterfaceKernel(), FVMassMatrix::FVMassMatrix(), AddMetaDataGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), SubdomainPerElementGenerator::generate(), BlockDeletionGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), SideSetsFromNodeSetsGenerator::generate(), MeshExtruderGenerator::generate(), ParsedExtraElementIDGenerator::generate(), XYZDelaunayGenerator::generate(), XYMeshLineCutter::generate(), XYDelaunayGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), PropertyReadFile::getFileNames(), MultiAppNearestNodeTransfer::getLocalEntitiesAndComponents(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getRenamedParam(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), Terminator::handleMessage(), HFEMDirichletBC::HFEMDirichletBC(), EigenExecutionerBase::init(), IterationAdaptiveDT::init(), Eigenvalue::init(), AdvancedOutput::initExecutionTypes(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), MultiAppVariableValueSampleTransfer::initialSetup(), PiecewiseTabularBase::initialSetup(), SolutionScalarAux::initialSetup(), ParsedConvergence::initialSetup(), SolutionAux::initialSetup(), Console::initialSetup(), MooseParsedVectorFunction::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), MooseParsedGradFunction::initialSetup(), MooseParsedFunction::initialSetup(), SampledOutput::initSample(), IterationAdaptiveDT::IterationAdaptiveDT(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MassMatrix::MassMatrix(), MatCoupledForce::MatCoupledForce(), MatDiffusionBase< Real >::MatDiffusionBase(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh::MooseMesh(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableFV< Real >::MooseVariableFV(), MortarConstraintBase::MortarConstraintBase(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), MultiAppGeneralFieldShapeEvaluationTransfer::MultiAppGeneralFieldShapeEvaluationTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppPostprocessorInterpolationTransfer::MultiAppPostprocessorInterpolationTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppReporterTransfer::MultiAppReporterTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSampleTransfer::MultiAppVariableValueSampleTransfer(), MultiSystemSolveObject::MultiSystemSolveObject(), NodeSetsGeneratorBase::NodeSetsGeneratorBase(), EigenExecutionerBase::normalizeSolution(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), ParsedCurveGenerator::ParsedCurveGenerator(), PetscOutput::PetscOutput(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseTabularBase::PiecewiseTabularBase(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), MooseMesh::prepare(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), SolutionUserObjectBase::readExodusII(), ReferenceResidualInterface::ReferenceResidualInterface(), RenameBlockGenerator::RenameBlockGenerator(), ReporterPointSource::ReporterPointSource(), PhysicsBase::reportPotentiallyMissedParameters(), ParsedSubdomainMeshGenerator::setBlockName(), MooseMesh::setCoordSystem(), FileOutput::setFileBase(), FileOutput::setFileBaseInternal(), Split::setup(), SideSetsGeneratorBase::setup(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), Output::setWallTimeIntervalFromCommandLineParam(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideSetsGeneratorBase::SideSetsGeneratorBase(), SolutionUserObjectBase::SolutionUserObjectBase(), WebServerControl::startServer(), Terminator::Terminator(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), MultiAppDofCopyTransfer::transfer(), TransformGenerator::TransformGenerator(), TransientBase::TransientBase(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

{ return _pars.isParamValid(name); }

isSNESMFReuseBaseSetbyUser()

bool FEProblemBase::isSNESMFReuseBaseSetbyUser ( )

inlineinherited

Return a flag to indicate if _snesmf_reuse_base is set by users.

Definition at line 2339 of file FEProblemBase.h.

{ return _snesmf_reuse_base_set_by_user; }

isSolverSystemNonlinear()

bool FEProblemBase::isSolverSystemNonlinear ( const unsigned int  sys_num )

inlineinherited

Check if the solver system is nonlinear.

Definition at line 2583 of file FEProblemBase.h.

Referenced by FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addKernel(), FEProblemBase::addScalarKernel(), and ConsoleUtils::outputExecutionInformation().

{ return sys_num < _num_nl_sys; }

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.

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

{ return _termination_requested; };

isTransient()

virtual bool FEProblemBase::isTransient ( ) const

inlineoverridevirtualinherited

Implements SubProblem.

Definition at line 552 of file FEProblemBase.h.

Referenced by addVariable(), FixedPointSolve::autoAdvance(), FEProblemBase::checkExceptionAndStopSolve(), PhysicsBase::isTransient(), DisplacedProblem::isTransient(), PIDTransientControl::PIDTransientControl(), PseudoTimestep::PseudoTimestep(), TimePeriodBase::TimePeriodBase(), ScalarCoupleable::validateExecutionerType(), and Coupleable::validateExecutionerType().

{ return _transient; }

jacobianSetup()

void FEProblemBase::jacobianSetup ( )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 9449 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::jacobianSetup().

{
  SubProblem::jacobianSetup();
  // We need to setup all the nonlinear systems other than our current one which actually called
  // this method (so we have to make sure we don't go in a circle)
  for (const auto i : make_range(numNonlinearSystems()))
    if (i != currentNlSysNum())
      _nl[i]->jacobianSetup();
  // We don't setup the aux sys because that's been done elsewhere
  if (_displaced_problem)
    _displaced_problem->jacobianSetup();
}

kokkosAssembly() [1/2]

Moose::Kokkos::Assembly& FEProblemBase::kokkosAssembly ( )

inlineinherited

Definition at line 333 of file FEProblemBase.h.

{ return _kokkos_assembly; }

kokkosAssembly() [2/2]

const Moose::Kokkos::Assembly& FEProblemBase::kokkosAssembly ( ) const

inlineinherited

Definition at line 334 of file FEProblemBase.h.

{ return _kokkos_assembly; }

linearSysNum()

unsigned int FEProblemBase::linearSysNum ( const LinearSystemName &  linear_sys_name ) const

overridevirtualinherited

Returns

the linear system number corresponding to the provided linear_sys_name

Implements SubProblem.

Definition at line 6551 of file FEProblemBase.C.

Referenced by Moose::compute_linear_system(), LinearSystem::computeGradients(), FEProblemBase::computeLinearSystemSys(), LinearSystem::computeLinearSystemTags(), and DisplacedProblem::linearSysNum().

{
  std::istringstream ss(linear_sys_name);
  unsigned int linear_sys_num;
  if (!(ss >> linear_sys_num) || !ss.eof())
    linear_sys_num = libmesh_map_find(_linear_sys_name_to_num, linear_sys_name);

  return linear_sys_num;
}

lineSearch()

void FEProblemBase::lineSearch ( )

virtualinherited

execute MOOSE line search

Definition at line 2713 of file FEProblemBase.C.

Referenced by ComputeLineSearchObjectWrapper::linesearch().

{
  _line_search->lineSearch();
}

logAdd()

void FEProblemBase::logAdd ( const std::string &  system, const std::string &  name, const std::string &  type, const InputParameters &  params  ) const

inherited

Output information about the object just added to the problem.

Definition at line 4398 of file FEProblemBase.C.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarKernel(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addFunction(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addIndicator(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addOutput(), FEProblemBase::addPredictor(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), FEProblemBase::addVariable(), FEProblemBase::setAuxKernelParamsAndLog(), and FEProblemBase::setResidualObjectParamsAndLog().

{
  if (_verbose_setup != "false")
    _console << "[DBG] Adding " << system << " '" << name << "' of type " << type << std::endl;
  if (_verbose_setup == "extra")
    _console << params << std::endl;
}

markFamilyPRefinement()

void SubProblem::markFamilyPRefinement ( const InputParameters &  params )

protectedinherited

Mark a variable family for either disabling or enabling p-refinement with valid parameters of a variable.

Definition at line 1372 of file SubProblem.C.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxVariable(), and FEProblemBase::addVariable().

{
  auto family = Utility::string_to_enum<FEFamily>(params.get<MooseEnum>("family"));
  bool flag = _default_families_without_p_refinement.count(family);
  if (params.isParamValid("disable_p_refinement"))
    flag = params.get<bool>("disable_p_refinement");

  auto [it, inserted] = _family_for_p_refinement.emplace(family, flag);
  if (!inserted && flag != it->second)
    mooseError("'disable_p_refinement' not set consistently for variables in ", family);
}

markMatPropRequested()

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

virtualinherited

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

Definition at line 725 of file SubProblem.C.

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

{
  _material_property_requested.insert(prop_name);
}

matrixTagExists() [1/2]

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

virtualinherited

Check to see if a particular Tag exists.

Reimplemented in DisplacedProblem.

Definition at line 329 of file SubProblem.C.

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

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

matrixTagExists() [2/2]

bool SubProblem::matrixTagExists ( TagID  tag_id ) const

virtualinherited

Check to see if a particular Tag exists.

Reimplemented in DisplacedProblem.

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

virtualinherited

Retrieve the name associated with a TagID.

Reimplemented in DisplacedProblem.

Definition at line 358 of file SubProblem.C.

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

{
  return _matrix_tag_id_to_tag_name[tag];
}

mesh() [1/3]

MFEMMesh & MFEMProblem::mesh ( )

overridevirtual

Overwritten mesh() method from base MooseMesh to retrieve the correct mesh type, in this case MFEMMesh.

Reimplemented from FEProblemBase.

Definition at line 466 of file MFEMProblem.C.

Referenced by addMFEMFESpaceFromMOOSEVariable(), displaceMesh(), getMeshDisplacementGridFunction(), MFEMSimplifiedFESpace::getProblemDim(), mesh(), and setMesh().

{
  mooseAssert(ExternalProblem::mesh().type() == "MFEMMesh",
              "Please choose the MFEMMesh mesh type for an MFEMProblem\n");
  return static_cast<MFEMMesh &>(_mesh);
}

mesh() [2/3]

const MFEMMesh & MFEMProblem::mesh ( ) const

overridevirtual

Reimplemented from FEProblemBase.

Definition at line 474 of file MFEMProblem.C.

{
  return const_cast<MFEMProblem *>(this)->mesh();
}

mesh() [3/3]

const MooseMesh & FEProblemBase::mesh ( bool  use_displaced ) const

overridevirtualinherited

Implements SubProblem.

Definition at line 665 of file FEProblemBase.C.

{
  if (use_displaced && !_displaced_problem)
    mooseWarning("Displaced mesh was requested but the displaced problem does not exist. "
                 "Regular mesh will be returned");
  return ((use_displaced && _displaced_problem) ? _displaced_problem->mesh() : mesh());
}

meshChanged() [1/2]

void FEProblemBase::meshChanged ( bool  intermediate_change, bool  contract_mesh, bool  clean_refinement_flags  )

virtualinherited

Update data after a mesh change.

Iff intermediate_change is true, only perform updates as necessary to prepare for another mesh change immediately-subsequent. An example of data that is not updated during an intermediate change is libMesh System matrix data. An example of data that is updated during an intermediate change is libMesh System vectors. These vectors are projected or restricted based off of adaptive mesh refinement or the changing of element subdomain IDs. The flags contract_mesh and clean_refinement_flags should generally only be set to true when the mesh has changed due to mesh refinement. contract_mesh deletes children of coarsened elements and renumbers nodes and elements. clean_refinement_flags resets refinement flags such that any subsequent calls to System::restrict_vectors or System::prolong_vectors before another AMR step do not mistakenly attempt to re-do the restriction/prolongation which occurred in this method

Definition at line 8311 of file FEProblemBase.C.

Referenced by SidesetAroundSubdomainUpdater::finalize(), ActivateElementsUserObjectBase::finalize(), Exodus::handleExodusIOMeshRenumbering(), ElementSubdomainModifierBase::modify(), and Adaptivity::uniformRefineWithProjection().

{
  TIME_SECTION("meshChanged", 3, "Handling Mesh Changes");

  if (_material_props.hasStatefulProperties() || _bnd_material_props.hasStatefulProperties() ||
      _neighbor_material_props.hasStatefulProperties())
    _mesh.cacheChangedLists(); // Currently only used with adaptivity and stateful material
                               // properties

  // Clear these out because they corresponded to the old mesh
  _ghosted_elems.clear();
  ghostGhostedBoundaries();

  // The mesh changed.  We notify the MooseMesh first, because
  // callbacks (e.g. for sparsity calculations) triggered by the
  // EquationSystems reinit may require up-to-date MooseMesh caches.
  _mesh.meshChanged();

  // If we're just going to alter the mesh again, all we need to
  // handle here is AMR and projections, not full system reinit
  if (intermediate_change)
    es().reinit_solutions();
  else
    es().reinit();

  if (contract_mesh)
    // Once vectors are restricted, we can delete children of coarsened elements
    _mesh.getMesh().contract();
  if (clean_refinement_flags)
  {
    // Finally clear refinement flags so that if someone tries to project vectors again without
    // an intervening mesh refinement to clear flags they won't run into trouble
    MeshRefinement refinement(_mesh.getMesh());
    refinement.clean_refinement_flags();
  }

  if (!intermediate_change)
  {
    // Since the mesh has changed, we need to make sure that we update any of our
    // MOOSE-system specific data.
    for (auto & sys : _solver_systems)
      sys->reinit();
    _aux->reinit();
  }

  // Updating MooseMesh first breaks other adaptivity code, unless we
  // then *again* update the MooseMesh caches.  E.g. the definition of
  // "active" and "local" may have been *changed* by refinement and
  // repartitioning done in EquationSystems::reinit().
  _mesh.meshChanged();

  // If we have finite volume variables, we will need to recompute additional elemental/face
  // quantities
  if (haveFV() && _mesh.isFiniteVolumeInfoDirty())
    _mesh.setupFiniteVolumeMeshData();

  // Let the meshChangedInterface notify the mesh changed event before we update the active
  // semilocal nodes, because the set of ghosted elements may potentially be updated during a mesh
  // changed event.
  for (const auto & mci : _notify_when_mesh_changes)
    mci->meshChanged();

  // Since the Mesh changed, update the PointLocator object used by DiracKernels.
  _dirac_kernel_info.updatePointLocator(_mesh);

  // Need to redo ghosting
  _geometric_search_data.reinit();

  if (_displaced_problem)
  {
    _displaced_problem->meshChanged(contract_mesh, clean_refinement_flags);
    _displaced_mesh->updateActiveSemiLocalNodeRange(_ghosted_elems);
  }

  _mesh.updateActiveSemiLocalNodeRange(_ghosted_elems);

  _evaluable_local_elem_range.reset();
  _nl_evaluable_local_elem_range.reset();

  // Just like we reinitialized our geometric search objects, we also need to reinitialize our
  // mortar meshes. Note that this needs to happen after DisplacedProblem::meshChanged because the
  // mortar mesh discretization will depend necessarily on the displaced mesh being re-displaced
  updateMortarMesh();

  // Nonlinear systems hold the mortar mesh functors. The domains of definition of the mortar
  // functors might have changed when the mesh changed.
  for (auto & nl_sys : _nl)
    nl_sys->reinitMortarFunctors();

  reinitBecauseOfGhostingOrNewGeomObjects(/*mortar_changed=*/true);

  // We need to create new storage for newly active elements, and copy
  // stateful properties from the old elements.
  if (_has_initialized_stateful &&
      (_material_props.hasStatefulProperties() || _bnd_material_props.hasStatefulProperties()))
  {
    if (havePRefinement())
      _mesh.buildPRefinementAndCoarseningMaps(_assembly[0][0].get());

    // Prolong properties onto newly refined elements' children
    {
      ProjectMaterialProperties pmp(
          /* refine = */ true, *this, _material_props, _bnd_material_props, _assembly);
      const auto & range = *_mesh.refinedElementRange();
      Threads::parallel_reduce(range, pmp);

      // Concurrent erasure from the shared hash map is not safe while we are reading from it in
      // ProjectMaterialProperties, so we handle erasure here. Moreover, erasure based on key is
      // not thread safe in and of itself because it is a read-write operation. Note that we do not
      // do the erasure for p-refinement because the coarse level element is the same as our active
      // refined level element
      if (!doingPRefinement())
        for (const auto & elem : range)
        {
          _material_props.eraseProperty(elem);
          _bnd_material_props.eraseProperty(elem);
          _neighbor_material_props.eraseProperty(elem);
        }
    }

    // Restrict properties onto newly coarsened elements
    {
      ProjectMaterialProperties pmp(
          /* refine = */ false, *this, _material_props, _bnd_material_props, _assembly);
      const auto & range = *_mesh.coarsenedElementRange();
      Threads::parallel_reduce(range, pmp);
      // Note that we do not do the erasure for p-refinement because the coarse level element is the
      // same as our active refined level element
      if (!doingPRefinement())
        for (const auto & elem : range)
        {
          auto && coarsened_children = _mesh.coarsenedElementChildren(elem);
          for (auto && child : coarsened_children)
          {
            _material_props.eraseProperty(child);
            _bnd_material_props.eraseProperty(child);
            _neighbor_material_props.eraseProperty(child);
          }
        }
    }
  }

  if (_calculate_jacobian_in_uo)
    setVariableAllDoFMap(_uo_jacobian_moose_vars[0]);

  _has_jacobian = false; // we have to recompute jacobian when mesh changed

  // Now for backwards compatibility with user code that overrode the old no-arg meshChanged we must
  // call it here
  meshChanged();
}

meshChanged() [2/2]

virtual void FEProblemBase::meshChanged ( )

inlineprotectedvirtualinherited

Deprecated.

Users should switch to overriding the meshChanged which takes arguments

Definition at line 2729 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::initialAdaptMesh(), FEProblemBase::meshChanged(), FEProblemBase::timestepSetup(), FEProblemBase::uniformRefine(), and FEProblemBase::updateMeshXFEM().

{}

meshDisplaced()

void FEProblemBase::meshDisplaced ( )

protectedvirtualinherited

Update data after a mesh displaced.

Definition at line 8478 of file FEProblemBase.C.

Referenced by DisplacedProblem::updateMesh().

{
  for (const auto & mdi : _notify_when_mesh_displaces)
    mdi->meshDisplaced();
}

messagePrefix()

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.

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

  {
    return messagePrefix(_pars, hit_prefix);
  }

mooseDeprecated() [1/2]

template<typename... Args>

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

inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), AddVariableAction::determineType(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), MooseMesh::elem(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), MooseMesh::getBoundariesToElems(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), FEProblemBase::getUserObjects(), FEProblemBase::hasPostprocessor(), MatDiffusionBase< Real >::MatDiffusionBase(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodalScalarKernel::NodalScalarKernel(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), PercentChangePostprocessor::PercentChangePostprocessor(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Residual::Residual(), MooseMesh::setBoundaryToNormalMap(), Exodus::setOutputDimension(), TagVectorAux::TagVectorAux(), UserForcingFunction::UserForcingFunction(), and VariableResidual::VariableResidual().

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

mooseDeprecated() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 314 of file MooseBase.h.

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

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

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.

Referenced by ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), DGLowerDKernel::DGLowerDKernel(), HFEMDirichletBC::HFEMDirichletBC(), and LowerDIntegratedBC::LowerDIntegratedBC().

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

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.

Referenced by CopyMeshPartitioner::_do_partition(), HierarchicalGridPartitioner::_do_partition(), GridPartitioner::_do_partition(), PetscExternalPartitioner::_do_partition(), MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), AutoCheckpointAction::act(), AddMeshGeneratorAction::act(), CheckFVBCAction::act(), InitProblemAction::act(), AddBoundsVectorsAction::act(), AddVectorPostprocessorAction::act(), SetupMeshCompleteAction::act(), CreateExecutionerAction::act(), CheckIntegrityAction::act(), AddFVICAction::act(), AddICAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), CombineComponentsMeshes::act(), SetupMeshAction::act(), SplitMeshAction::act(), AdaptivityAction::act(), ChainControlSetupAction::act(), AddTimeStepperAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), SetupPredictorAction::act(), SetupTimeStepperAction::act(), CreateDisplacedProblemAction::act(), SetAdaptivityOptionsAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), AddMFEMSubMeshAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::adaptMesh(), MooseVariableFV< Real >::adCurlSln(), MooseVariableFV< Real >::adCurlSlnNeighbor(), AddActionComponentAction::AddActionComponentAction(), addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), DiffusionCG::addBoundaryConditionsFromComponents(), PhysicsComponentInterface::addBoundaryConditionsFromComponents(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), DistributedRectilinearMeshGenerator::addElement(), MooseApp::addExecutor(), FEProblemBase::addFunction(), SubProblem::addFunctor(), FEProblemBase::addFVInitialCondition(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addInitialCondition(), PhysicsComponentInterface::addInitialConditionsFromComponents(), FEProblemBase::addInterfaceKernel(), addKernel(), FEProblemBase::addKernel(), FEProblem::addLineSearch(), FEProblemBase::addLineSearch(), addMaterial(), MeshGenerator::addMeshSubgenerator(), addMFEMFESpaceFromMOOSEVariable(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), SubProblem::addPiecewiseByBlockLambdaFunctor(), DiracKernelBase::addPoint(), DistributedRectilinearMeshGenerator::addPoint(), DiracKernelBase::addPointWithValidId(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), MooseMesh::addQuadratureNode(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addScalarKernel(), AddVariableAction::addVariable(), FEProblemBase::addVectorPostprocessor(), SubProblem::addVectorTag(), MooseLinearVariableFV< Real >::adError(), ADInterfaceKernelTempl< T >::ADInterfaceKernelTempl(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), MooseVariableScalar::adUDot(), Output::advancedExecuteOn(), AdvectiveFluxAux::AdvectiveFluxAux(), MooseVariableBase::allDofIndices(), NEML2ModelExecutor::applyPredictor(), MooseApp::appNameToLibName(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayConstantIC::ArrayConstantIC(), ArrayDGKernel::ArrayDGKernel(), ArrayDiffusion::ArrayDiffusion(), ArrayFunctionIC::ArrayFunctionIC(), ArrayReaction::ArrayReaction(), ArrayTimeDerivative::ArrayTimeDerivative(), MooseApp::attachRelationshipManagers(), AddPeriodicBCAction::autoTranslationBoundaries(), AuxKernelBase::AuxKernelBase(), Function::average(), Axisymmetric2D3DSolutionFunction::Axisymmetric2D3DSolutionFunction(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BicubicSplineFunction::BicubicSplineFunction(), BlockDeletionGenerator::BlockDeletionGenerator(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), BoundingValueElementDamper::BoundingValueElementDamper(), BoundingValueNodalDamper::BoundingValueNodalDamper(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), MooseMesh::buildCoarseningMap(), MultiApp::buildComm(), DistributedRectilinearMeshGenerator::buildCube(), TimedSubdomainModifier::buildFromFile(), PiecewiseTabularBase::buildFromFile(), PiecewiseTabularBase::buildFromJSON(), TimedSubdomainModifier::buildFromParameters(), PiecewiseTabularBase::buildFromXY(), PiecewiseLinearBase::buildInterpolation(), MooseMesh::buildLowerDMesh(), TiledMesh::buildMesh(), GeneratedMesh::buildMesh(), SpiralAnnularMesh::buildMesh(), MeshGeneratorMesh::buildMesh(), ImageMeshGenerator::buildMesh3D(), ImageMesh::buildMesh3D(), MooseMesh::buildRefinementMap(), MaterialBase::buildRequiredMaterials(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), CartesianGridDivision::CartesianGridDivision(), CartesianMeshGenerator::CartesianMeshGenerator(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), EigenExecutionerBase::chebyshev(), SubProblem::checkBlockMatProps(), PhysicsBase::checkBlockRestrictionIdentical(), ComponentBoundaryConditionInterface::checkBoundaryConditionsAllRequested(), SubProblem::checkBoundaryMatProps(), PhysicsBase::checkComponentType(), IterationCountConvergence::checkConvergence(), MooseMesh::checkCoordinateSystems(), DiffusionLHDGAssemblyHelper::checkCoupling(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkDisplacementOrders(), FEProblemBase::checkDuplicatePostprocessorVariableNames(), DefaultConvergenceBase::checkDuplicateSetSharedExecutionerParams(), MooseMesh::checkDuplicateSubdomainNames(), FEProblemBase::checkExceptionAndStopSolve(), NEML2ModelExecutor::checkExecutionStage(), MaterialBase::checkExecutionStage(), MeshGenerator::checkGetMesh(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Steady::checkIntegrity(), EigenExecutionerBase::checkIntegrity(), Eigenvalue::checkIntegrity(), DefaultSteadyStateConvergence::checkIterationType(), DefaultMultiAppFixedPointConvergence::checkIterationType(), DefaultNonlinearConvergence::checkIterationType(), ExplicitTimeIntegrator::checkLinearConvergence(), MooseApp::checkMetaDataIntegrity(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), Sampler::checkReinitStatus(), MooseApp::checkReservedCapability(), MultiAppGeneralFieldNearestLocationTransfer::checkRestrictionsForSource(), MultiAppPostprocessorToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppScalarToAuxScalarTransfer::checkSiblingsTransferSupported(), MultiAppPostprocessorTransfer::checkSiblingsTransferSupported(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), MultiAppMFEMCopyTransfer::checkSiblingsTransferSupported(), MultiAppCopyTransfer::checkSiblingsTransferSupported(), MultiAppTransfer::checkSiblingsTransferSupported(), MFEMSolverBase::checkSpectralEquivalence(), MaterialBase::checkStatefulSanity(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), FEProblemBase::checkUserObjects(), Moose::PetscSupport::checkUserProvidedPetscOption(), DomainUserObject::checkVariable(), MultiAppTransfer::checkVariable(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), LibmeshPartitioner::clone(), MooseMesh::clone(), CombinerGenerator::CombinerGenerator(), ComparisonPostprocessor::comparisonIsTrue(), MooseVariableFieldBase::componentName(), CompositeFunction::CompositeFunction(), ElementH1ErrorFunctionAux::compute(), NodalPatchRecovery::compute(), FEProblemBase::computeBounds(), VariableCondensationPreconditioner::computeDInverseDiag(), CompositionDT::computeDT(), ArrayDGKernel::computeElemNeighJacobian(), ArrayDGKernel::computeElemNeighResidual(), InternalSideIntegralPostprocessor::computeFaceInfoIntegral(), SideIntegralPostprocessor::computeFaceInfoIntegral(), MooseVariableFieldBase::computeFaceValues(), TimeSequenceStepperBase::computeFailedDT(), IterationAdaptiveDT::computeFailedDT(), TimeStepper::computeFailedDT(), MooseMesh::computeFiniteVolumeCoords(), HistogramVectorPostprocessor::computeHistogram(), ArrayKernel::computeJacobian(), ArrayIntegratedBC::computeJacobian(), FVFluxKernel::computeJacobian(), NodalConstraint::computeJacobian(), FEProblemBase::computeJacobianTags(), LowerDIntegratedBC::computeLowerDOffDiagJacobian(), ArrayLowerDIntegratedBC::computeLowerDOffDiagJacobian(), EigenProblem::computeMatricesTags(), ArrayDGKernel::computeOffDiagElemNeighJacobian(), ArrayKernel::computeOffDiagJacobian(), ArrayIntegratedBC::computeOffDiagJacobian(), FVElementalKernel::computeOffDiagJacobian(), Moose::Kokkos::ResidualObject::computeOffDiagJacobian(), MortarScalarBase::computeOffDiagJacobianScalar(), DGLowerDKernel::computeOffDiagLowerDJacobian(), ArrayDGLowerDKernel::computeOffDiagLowerDJacobian(), MaterialBase::computeProperties(), SideFVFluxBCIntegral::computeQpIntegral(), ScalarKernel::computeQpJacobian(), CoupledTiedValueConstraint::computeQpJacobian(), TiedValueConstraint::computeQpJacobian(), NodalEqualValueConstraint::computeQpJacobian(), LinearNodalConstraint::computeQpJacobian(), EqualValueBoundaryConstraint::computeQpJacobian(), NodeElemConstraint::computeQpJacobian(), CoupledTiedValueConstraint::computeQpOffDiagJacobian(), ScalarKernel::computeQpResidual(), MassMatrix::computeQpResidual(), HDGKernel::computeQpResidual(), DiffusionLHDGDirichletBC::computeQpResidual(), NodalEqualValueConstraint::computeQpResidual(), DiffusionLHDGPrescribedGradientBC::computeQpResidual(), IPHDGBC::computeQpResidual(), KernelValue::computeQpResidual(), TorchScriptMaterial::computeQpValues(), InterfaceQpValueUserObject::computeRealValue(), ArrayKernel::computeResidual(), ArrayIntegratedBC::computeResidual(), FVFluxBC::computeResidual(), FVFluxKernel::computeResidual(), NodalConstraint::computeResidual(), FVFluxKernel::computeResidualAndJacobian(), ResidualObject::computeResidualAndJacobian(), FEProblemBase::computeResidualAndJacobian(), HDGKernel::computeResidualAndJacobianOnSide(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualTags(), FEProblemBase::computeResidualType(), KernelScalarBase::computeScalarOffDiagJacobian(), ADKernelScalarBase::computeScalarQpResidual(), ADMortarScalarBase::computeScalarQpResidual(), MortarScalarBase::computeScalarQpResidual(), KernelScalarBase::computeScalarQpResidual(), TimeStepper::computeStep(), ActuallyExplicitEuler::computeTimeDerivatives(), ExplicitEuler::computeTimeDerivatives(), ImplicitEuler::computeTimeDerivatives(), BDF2::computeTimeDerivatives(), NewmarkBeta::computeTimeDerivatives(), CentralDifference::computeTimeDerivatives(), CrankNicolson::computeTimeDerivatives(), LStableDirk2::computeTimeDerivatives(), LStableDirk3::computeTimeDerivatives(), ImplicitMidpoint::computeTimeDerivatives(), ExplicitTVDRK2::computeTimeDerivatives(), AStableDirk4::computeTimeDerivatives(), LStableDirk4::computeTimeDerivatives(), ExplicitRK2::computeTimeDerivatives(), MultiAppGeometricInterpolationTransfer::computeTransformation(), BuildArrayVariableAux::computeValue(), TagVectorArrayVariableAux::computeValue(), NearestNodeValueAux::computeValue(), ProjectionAux::computeValue(), PenetrationAux::computeValue(), ConcentricCircleMesh::ConcentricCircleMesh(), ConditionalEnableControl::ConditionalEnableControl(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), TimeStepper::constrainStep(), LibtorchNeuralNetControl::controlNeuralNet(), TransientBase::convergedToSteadyState(), ParsedConvergence::convertRealToBool(), MooseApp::copyInputs(), CopyMeshPartitioner::CopyMeshPartitioner(), CoupledForceNodalKernel::CoupledForceNodalKernel(), MultiApp::createApp(), MooseApp::createExecutors(), AddVariableAction::createInitialConditionAction(), MooseApp::createRMFromTemplateAndInit(), Function::curl(), MooseVariableFV< Real >::curlPhi(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), SidesetInfoVectorPostprocessor::dataHelper(), ReporterTransferInterface::declareClone(), Moose::Kokkos::MaterialBase::declareKokkosPropertyByName(), MeshGenerator::declareMeshProperty(), ReporterTransferInterface::declareVectorClone(), DefaultSteadyStateConvergence::DefaultSteadyStateConvergence(), FunctorRelationshipManager::delete_remote_elements(), MooseMesh::deleteRemoteElements(), BicubicSplineFunction::derivative(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), MooseMesh::detectPairedSidesets(), MooseApp::determineLibtorchDeviceType(), FEProblemBase::determineSolverSystem(), DGKernel::DGKernel(), MeshDiagnosticsGenerator::diagnosticsLog(), DistributedPositions::DistributedPositions(), Function::div(), FunctorBinnedValuesDivision::divisionIndex(), MooseVariableFV< Real >::divPhi(), FunctorRelationshipManager::dofmap_reinit(), EigenProblem::doFreeNonlinearPowerIterations(), FEProblemBase::duplicateVariableCheck(), MooseApp::dynamicAllRegistration(), MooseApp::dynamicAppRegistration(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), Eigenvalues::Eigenvalues(), ElementalVariableValue::ElementalVariableValue(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementIntegerAux::ElementIntegerAux(), ElementMaterialSampler::ElementMaterialSampler(), ElementQualityAux::ElementQualityAux(), ElementUOAux::ElementUOAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), DistributedRectilinearMeshGenerator::elemId(), ProjectionAux::elemOnNodeVariableIsDefinedOn(), EigenKernel::enabled(), MooseApp::errorCheck(), MooseMesh::errorIfDistributedMesh(), MultiAppTransfer::errorIfObjectExecutesOnTransferInSourceApp(), SideIntegralPostprocessor::errorNoFaceInfo(), SideIntegralFunctorPostprocessorTempl< false >::errorNoFaceInfo(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), FixedPointSolve::examineFixedPointConvergence(), MultiAppGeneralFieldTransfer::examineReceivedValueConflicts(), RealToBoolChainControl::execute(), RestartableDataReporter::execute(), DiscreteElementUserObject::execute(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), NodalValueSampler::execute(), PositionsFunctorValueSampler::execute(), MultiAppPostprocessorInterpolationTransfer::execute(), ElementQualityChecker::execute(), MultiAppPostprocessorTransfer::execute(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), MultiAppVariableValueSampleTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), FindValueOnLine::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppMFEMCopyTransfer::execute(), MultiAppCopyTransfer::execute(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppUserObjectTransfer::execute(), InterfaceQpUserObjectBase::execute(), WebServerControl::execute(), TransientBase::execute(), LeastSquaresFit::execute(), LeastSquaresFitHistory::execute(), VectorPostprocessorComparison::execute(), Eigenvalue::execute(), TimeExtremeValue::execute(), DomainUserObject::execute(), FEProblemBase::execute(), FEProblemBase::executeControls(), MooseApp::executeExecutioner(), MultiAppVectorPostprocessorTransfer::executeFromMultiapp(), MultiAppVectorPostprocessorTransfer::executeToMultiapp(), Exodus::Exodus(), ExplicitSSPRungeKutta::ExplicitSSPRungeKutta(), MultiAppGeneralFieldTransfer::extractOutgoingPoints(), NEML2ModelExecutor::extractOutputs(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemSolve::FEProblemSolve(), FileOutput::FileOutput(), NEML2ModelExecutor::fillInputs(), QuadraturePointMultiApp::fillPositions(), CentroidMultiApp::fillPositions(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), VerifyNodalUniqueID::finalize(), VerifyElementUniqueID::finalize(), ParsedVectorReporter::finalize(), ParsedVectorVectorRealReductionReporter::finalize(), DiscreteElementUserObject::finalize(), ElementQualityChecker::finalize(), MemoryUsage::finalize(), PointSamplerBase::finalize(), DiscreteVariableResidualNorm::finalize(), NearestPointAverage::finalize(), NearestPointIntegralVariablePostprocessor::finalize(), MooseApp::finalizeRestore(), Transfer::find_sys(), BreakMeshByBlockGeneratorBase::findFreeBoundaryId(), FunctionDT::FunctionDT(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVMassMatrix::FVMassMatrix(), FVMatAdvection::FVMatAdvection(), FVScalarLagrangeMultiplierInterface::FVScalarLagrangeMultiplierInterface(), GapValueAux::GapValueAux(), WorkBalance::gather(), ElementSubdomainModifierBase::gatherPatchElements(), Boundary2DDelaunayGenerator::General2DDelaunay(), ElementOrderConversionGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), SideSetsFromNormalsGenerator::generate(), SmoothMeshGenerator::generate(), SubdomainPerElementGenerator::generate(), TiledMeshGenerator::generate(), ExtraNodesetGenerator::generate(), FileMeshGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), MoveNodeGenerator::generate(), SideSetsFromPointsGenerator::generate(), StitchMeshGenerator::generate(), MeshDiagnosticsGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), MeshRepairGenerator::generate(), ParsedGenerateNodeset::generate(), SideSetsFromBoundingBoxGenerator::generate(), StackGenerator::generate(), XYZDelaunayGenerator::generate(), CombinerGenerator::generate(), AllSideSetsByNormalsGenerator::generate(), AdvancedExtruderGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), SpiralAnnularMeshGenerator::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), CutMeshByLevelSetGeneratorBase::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), DistributedRectilinearMeshGenerator::generate(), BoundingBoxNodeSetGenerator::generate(), MeshGenerator::generateCSG(), MeshGenerator::generateData(), GeneratedMesh::GeneratedMesh(), GeneratedMeshGenerator::GeneratedMeshGenerator(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), CircularBoundaryCorrectionGenerator::generateRadialCorrectionFactor(), RandomICBase::generateRandom(), GenericConstantMaterialTempl< is_ad >::GenericConstantMaterialTempl(), GenericConstantVectorMaterialTempl< is_ad >::GenericConstantVectorMaterialTempl(), GenericFunctionMaterialTempl< is_ad >::GenericFunctionMaterialTempl(), GenericFunctionVectorMaterialTempl< is_ad >::GenericFunctionVectorMaterialTempl(), GenericFunctorGradientMaterialTempl< is_ad >::GenericFunctorGradientMaterialTempl(), GenericFunctorMaterialTempl< is_ad >::GenericFunctorMaterialTempl(), GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl(), GenericVectorFunctorMaterialTempl< is_ad >::GenericVectorFunctorMaterialTempl(), DisplacedProblem::getActualFieldVariable(), FEProblemBase::getActualFieldVariable(), DisplacedProblem::getArrayVariable(), FEProblemBase::getArrayVariable(), MooseMesh::getAxisymmetricRadialCoord(), NEML2BatchIndexGenerator::getBatchIndex(), MooseMesh::getBlockConnectedBlocks(), VariableOldValueBounds::getBound(), MooseMesh::getBoundaryID(), MultiApp::getBoundingBox(), ChainControl::getChainControlDataByName(), MooseMesh::getCoarseningMap(), NodalPatchRecoveryBase::getCoefficients(), MultiApp::getCommandLineArgs(), MooseVariableBase::getContinuity(), Control::getControllableParameterByName(), FEProblemBase::getConvergence(), MooseMesh::getCoordSystem(), PhysicsBase::getCoupledPhysics(), MeshGenerator::getCSGBaseByName(), PropertyReadFile::getData(), DataFileInterface::getDataFilePath(), TransfiniteMeshGenerator::getDiscreteEdge(), FEProblemBase::getDistribution(), MooseVariableBase::getDofIndices(), VariableCondensationPreconditioner::getDofToCondense(), TransfiniteMeshGenerator::getEdge(), GhostingUserObject::getElementalValue(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), PropertyReadFile::getElementData(), MooseMesh::getElementIDIndex(), Material::getElementIDNeighbor(), Material::getElementIDNeighborByName(), MooseMesh::getElemIDMapping(), MooseMesh::getElemIDsOnBlocks(), MultiAppFieldTransfer::getEquationSystem(), MultiApp::getExecutioner(), MooseApp::getExecutor(), MFEMVectorFESpace::getFECName(), MultiAppTransfer::getFromMultiApp(), MultiAppTransfer::getFromMultiAppInfo(), FEProblemBase::getFunction(), SubProblem::getFunctor(), FEProblemBase::getFVMatsAndDependencies(), MooseMesh::getGeneralAxisymmetricCoordAxis(), DistributedRectilinearMeshGenerator::getGhostNeighbors(), DistributedRectilinearMeshGenerator::getIndices(), FEProblemBase::getLinearConvergenceNames(), SolutionUserObjectBase::getLocalVarIndex(), Material::getMaterialByName(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), SubProblem::getMatrixTagID(), GeneratedMesh::getMaxInDimension(), AnnularMesh::getMaxInDimension(), FEProblemBase::getMaxQps(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), AnnularMesh::getMinInDimension(), GeneratedMesh::getMinInDimension(), MultiAppTransfer::getMultiApp(), FEProblemBase::getMultiAppFixedPointConvergenceName(), DistributedRectilinearMeshGenerator::getNeighbors(), Times::getNextTime(), MooseMesh::getNodeBlockIds(), PropertyReadFile::getNodeData(), MooseMesh::getNodeList(), FEProblemBase::getNonlinearConvergenceNames(), EigenProblem::getNonlinearEigenSystem(), FEProblemBase::getNonlinearSystem(), NEML2ModelExecutor::getOutput(), NEML2ModelExecutor::getOutputDerivative(), NEML2ModelExecutor::getOutputParameterDerivative(), MooseMesh::getPairedBoundaryMapping(), MaterialOutputAction::getParams(), ImageMeshGenerator::GetPixelInfo(), ImageMesh::GetPixelInfo(), PlaneIDMeshGenerator::getPlaneID(), Positions::getPosition(), Positions::getPositions(), FEProblemBase::getPositionsObject(), Positions::getPositionsVector2D(), Positions::getPositionsVector3D(), Positions::getPositionsVector4D(), PostprocessorInterface::getPostprocessorValueByNameInternal(), Times::getPreviousTime(), ComponentMaterialPropertyInterface::getPropertyValue(), InterfaceQpUserObjectBase::getQpValue(), MooseMesh::getRefinementMap(), MooseBase::getRenamedParam(), ReporterInterface::getReporterContextBaseByName(), ReporterInterface::getReporterName(), Reporter::getReporterValueName(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), MooseApp::getRMClone(), FEProblemBase::getSampler(), WebServerControl::getScalarJSONValue(), DisplacedProblem::getScalarVariable(), FEProblemBase::getScalarVariable(), MooseObject::getSharedPtr(), InterfaceQpUserObjectBase::getSideAverageValue(), PhysicsBase::getSolverSystem(), DisplacedProblem::getStandardVariable(), FEProblemBase::getStandardVariable(), FEProblemBase::getSteadyStateConvergenceName(), MooseMesh::getSubdomainBoundaryIds(), TimedSubdomainModifier::getSubdomainIDAndCheck(), DisplacedProblem::getSystem(), FEProblemBase::getSystem(), FEProblemBase::getSystemBase(), Times::getTimeAtIndex(), FEProblemBase::getTimeFromStateArg(), TransientBase::getTimeIntegratorNames(), Times::getTimes(), MultiAppTransfer::getToMultiApp(), MultiAppTransfer::getToMultiAppInfo(), MooseMesh::getUniqueCoordSystem(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), UserObjectInterface::getUserObjectBaseByName(), UserObjectInterface::getUserObjectName(), VectorPostprocessorComponent::getValue(), NumRelationshipManagers::getValue(), Residual::getValue(), SideAverageValue::getValue(), JSONFileReader::getValue(), LineValueSampler::getValue(), FindValueOnLine::getValueAtPoint(), SubProblem::getVariableHelper(), JSONFileReader::getVector(), VectorPostprocessorInterface::getVectorPostprocessorName(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), DisplacedProblem::getVectorVariable(), FEProblemBase::getVectorVariable(), GhostingFromUOAux::GhostingFromUOAux(), MultiApp::globalAppToLocal(), MooseParsedVectorFunction::gradient(), Function::gradient(), FEProblemBase::handleException(), Terminator::handleMessage(), MooseVariableBase::hasDoFsOnNodes(), PostprocessorInterface::hasPostprocessor(), PostprocessorInterface::hasPostprocessorByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), HDGKernel::HDGKernel(), TransientBase::incrementStepOrReject(), FixedPointIterationAdaptiveDT::init(), CrankNicolson::init(), CSVTimeSequenceStepper::init(), ExplicitTimeIntegrator::init(), EigenExecutionerBase::init(), TransientBase::init(), FEProblem::init(), AddAuxVariableAction::init(), IterationAdaptiveDT::init(), Eigenvalue::init(), AddVariableAction::init(), MooseMesh::init(), Sampler::init(), FEProblemBase::init(), MultiApp::init(), FEProblemBase::initialAdaptMesh(), NestedDivision::initialize(), DistributedPositions::initialize(), ReporterPositions::initialize(), TransformedPositions::initialize(), ElementGroupCentroidPositions::initialize(), FunctorPositions::initialize(), ReporterTimes::initialize(), FunctorTimes::initialize(), ParsedDownSelectionPositions::initialize(), ParsedConvergence::initializeConstantSymbol(), PhysicsBase::initializePhysics(), SteffensenSolve::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), ChainControlDataPostprocessor::initialSetup(), MultiAppConservativeTransfer::initialSetup(), PiecewiseLinearBase::initialSetup(), IntegralPreservingFunctionIC::initialSetup(), FullSolveMultiApp::initialSetup(), PiecewiseLinear::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), CoarsenedPiecewiseLinear::initialSetup(), SolutionScalarAux::initialSetup(), LinearFVDiffusion::initialSetup(), LinearFVAdvection::initialSetup(), LinearFVAnisotropicDiffusion::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), SolutionAux::initialSetup(), ExplicitTimeIntegrator::initialSetup(), ReferenceResidualConvergence::initialSetup(), NodalVariableValue::initialSetup(), Axisymmetric2D3DSolutionFunction::initialSetup(), ElementSubdomainModifierBase::initialSetup(), Exodus::initialSetup(), CSV::initialSetup(), MooseParsedFunction::initialSetup(), SolutionUserObjectBase::initialSetup(), FEProblemBase::initialSetup(), SubProblem::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initShowHideLists(), Function::integral(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), InterfaceTimeKernel::InterfaceTimeKernel(), InternalSideIndicatorBase::InternalSideIndicatorBase(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), EigenExecutionerBase::inversePowerIteration(), InversePowerMethod::InversePowerMethod(), Sampler::isAdaptiveSamplingCompleted(), MooseMesh::isBoundaryFullyExternalToSubdomains(), MooseVariableBase::isNodal(), IterationAdaptiveDT::IterationAdaptiveDT(), IterationCountConvergence::IterationCountConvergence(), LeastSquaresFit::LeastSquaresFit(), LibmeshPartitioner::LibmeshPartitioner(), MooseApp::libNameToAppName(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), LinearNodalConstraint::LinearNodalConstraint(), LineMaterialSamplerBase< Real >::LineMaterialSamplerBase(), LineSearch::lineSearch(), LineValueSampler::LineValueSampler(), MooseApp::loadLibraryAndDependencies(), MultiAppGeneralFieldTransfer::locatePointReceivers(), LowerBoundNodalKernel::LowerBoundNodalKernel(), MooseLinearVariableFV< Real >::lowerDError(), PNGOutput::makePNG(), ReporterPointMarker::markerSetup(), SubProblem::markFamilyPRefinement(), MassMatrix::MassMatrix(), Material::Material(), MaterialRealTensorValueAuxTempl< is_ad >::MaterialRealTensorValueAuxTempl(), MaterialRealVectorValueAuxTempl< T, is_ad, is_functor >::MaterialRealVectorValueAuxTempl(), MaterialStdVectorRealGradientAux::MaterialStdVectorRealGradientAux(), Distribution::median(), FunctorRelationshipManager::mesh_reinit(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshExtruderGenerator::MeshExtruderGenerator(), MeshRepairGenerator::MeshRepairGenerator(), SetupMeshAction::modifyParamsForUseSplit(), MeshMetaDataInterface::mooseErrorInternal(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MooseVariableConstMonomial::MooseVariableConstMonomial(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppMFEMCopyTransfer::MultiAppMFEMCopyTransfer(), MultiAppPostprocessorTransfer::MultiAppPostprocessorTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NearestNodeDistanceAux::NearestNodeDistanceAux(), FEProblemBase::needsPreviousNewtonIteration(), NewmarkBeta::NewmarkBeta(), NodalConstraint::NodalConstraint(), MooseVariableFV< Real >::nodalDofIndex(), MooseVariableFV< Real >::nodalDofIndexNeighbor(), MooseLinearVariableFV< Real >::nodalError(), MooseVariableFV< Real >::nodalMatrixTagValue(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalScalarKernel::NodalScalarKernel(), MooseVariableFV< Real >::nodalValueArray(), MooseVariableFV< Real >::nodalValueOldArray(), MooseVariableFV< Real >::nodalValueOlderArray(), NodalVariableValue::NodalVariableValue(), MooseVariableFV< Real >::nodalVectorTagValue(), DistributedRectilinearMeshGenerator::nodeId(), MooseVariableFV< Real >::numberOfDofsNeighbor(), NumDOFs::NumDOFs(), NumFailedTimeSteps::NumFailedTimeSteps(), DistributedRectilinearMeshGenerator::numNeighbors(), NumNonlinearIterations::NumNonlinearIterations(), NumVars::NumVars(), Output::onInterval(), FunctorRelationshipManager::operator()(), RelationshipManager::operator==(), ActionComponent::outerSurfaceArea(), ActionComponent::outerSurfaceBoundaries(), XDA::output(), SolutionHistory::output(), Exodus::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), AdvancedOutput::outputInput(), MooseApp::outputMachineReadableData(), AdvancedOutput::outputNodalVariables(), AdvancedOutput::outputPostprocessors(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), Exodus::outputSetup(), AdvancedOutput::outputSystemInformation(), Console::outputVectorPostprocessors(), AdvancedOutput::outputVectorPostprocessors(), DistributedRectilinearMeshGenerator::paritionSquarely(), PiecewiseBilinear::parse(), ParsedConvergence::ParsedConvergence(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), MultiAppConservativeTransfer::performAdjustment(), ExplicitTimeIntegrator::performExplicitSolve(), PetscExternalPartitioner::PetscExternalPartitioner(), MooseVariableFV< Real >::phiLowerSize(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), PIDTransientControl::PIDTransientControl(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseLinearInterpolationMaterial::PiecewiseLinearInterpolationMaterial(), PiecewiseMulticonstant::PiecewiseMulticonstant(), PiecewiseMultiInterpolation::PiecewiseMultiInterpolation(), PiecewiseTabularBase::PiecewiseTabularBase(), CutMeshByLevelSetGeneratorBase::pointPairLevelSetInterception(), SolutionUserObjectBase::pointValueGradientWrapper(), SolutionUserObjectBase::pointValueWrapper(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName(), LStableDirk2::postResidual(), LStableDirk3::postResidual(), ImplicitMidpoint::postResidual(), ExplicitTVDRK2::postResidual(), LStableDirk4::postResidual(), AStableDirk4::postResidual(), ExplicitRK2::postResidual(), EigenProblem::postScaleEigenVector(), VariableCondensationPreconditioner::preallocateCondensedJacobian(), ADKernelValueTempl< T >::precomputeQpJacobian(), FunctorKernel::precomputeQpResidual(), Predictor::Predictor(), TransientBase::preExecute(), MooseMesh::prepare(), MooseMesh::prepared(), ElementSubdomainModifierBase::prepareVariableForReinitialization(), FixedPointSolve::printFixedPointConvergenceReason(), PseudoTimestep::PseudoTimestep(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readExodusII(), SolutionUserObjectBase::readXda(), CoarsenBlockGenerator::recursiveCoarsen(), MooseApp::recursivelyCreateExecutors(), FunctorRelationshipManager::redistribute(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MooseApp::registerRestartableData(), MooseApp::registerRestartableNameWithFilter(), Sampler::reinit(), RelativeSolutionDifferenceNorm::RelativeSolutionDifferenceNorm(), MFEMTransient::relativeSolutionDifferenceNorm(), MooseApp::removeRelationshipManager(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::restore(), RinglebMesh::RinglebMesh(), RinglebMeshGenerator::RinglebMeshGenerator(), MooseApp::run(), MooseApp::runInputs(), PiecewiseMultiInterpolation::sample(), ScalarComponentIC::ScalarComponentIC(), MortarScalarBase::scalarVariable(), DistributedRectilinearMeshGenerator::scaleNodalPositions(), BicubicSplineFunction::secondDerivative(), MooseVariableFV< Real >::secondPhi(), MooseVariableFV< Real >::secondPhiFace(), MooseVariableFV< Real >::secondPhiFaceNeighbor(), MooseVariableFV< Real >::secondPhiNeighbor(), FunctorRelationshipManager::set_mesh(), MooseVariableBase::setActiveTags(), DistributedRectilinearMeshGenerator::setBoundaryNames(), MooseMesh::setCoordSystem(), FEProblemBase::setCoupling(), PiecewiseBase::setData(), FileOutput::setFileBaseInternal(), MooseMesh::setGeneralAxisymmetricCoordAxes(), FEProblemSolve::setInnerSolve(), MeshGenerator::setMeshProperty(), MooseApp::setMFEMDevice(), FVPointValueConstraint::setMyElem(), FEProblemBase::setNonlocalCouplingMatrix(), Sampler::setNumberOfCols(), Sampler::setNumberOfRandomSeeds(), Sampler::setNumberOfRows(), Exodus::setOutputDimensionInExodusWriter(), AddPeriodicBCAction::setPeriodicVars(), MFEMSolverBase::setPreconditioner(), MultiAppGeneralFieldTransfer::setSolutionVectorValues(), Split::setup(), TransientMultiApp::setupApp(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), TimePeriodBase::setupTimes(), IntegratedBCBase::shouldApply(), PhysicsBase::shouldCreateIC(), PhysicsBase::shouldCreateTimeDerivative(), PhysicsBase::shouldCreateVariable(), SideAdvectiveFluxIntegralTempl< is_ad >::SideAdvectiveFluxIntegralTempl(), SideDiffusiveFluxIntegralTempl< is_ad, Real >::SideDiffusiveFluxIntegralTempl(), SideSetsFromNormalsGenerator::SideSetsFromNormalsGenerator(), SideSetsFromPointsGenerator::SideSetsFromPointsGenerator(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), MooseVariableBase::sizeMatrixTagData(), SolutionTimeAdaptiveDT::SolutionTimeAdaptiveDT(), SolutionUserObjectBase::SolutionUserObjectBase(), ExplicitTVDRK2::solve(), ExplicitRK2::solve(), TimeIntegrator::solve(), FEProblemBase::solverSysNum(), FullSolveMultiApp::solveStep(), SpatialAverageBase::SpatialAverageBase(), UserObject::spatialPoints(), NearestPointIntegralVariablePostprocessor::spatialValue(), NearestPointAverage::spatialValue(), MeshDivisionFunctorReductionVectorPostprocessor::spatialValue(), UserObject::spatialValue(), SpiralAnnularMesh::SpiralAnnularMesh(), SpiralAnnularMeshGenerator::SpiralAnnularMeshGenerator(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), WebServerControl::stringifyJSONType(), MultiAppGeometricInterpolationTransfer::subdomainIDsNode(), Constraint::subdomainSetup(), NodalUserObject::subdomainSetup(), GeneralUserObject::subdomainSetup(), MaterialBase::subdomainSetup(), FEProblemBase::swapBackMaterialsNeighbor(), DisplacedProblem::systemBaseLinear(), Console::systemInfoFlags(), FEProblemBase::systemNumForVariable(), TerminateChainControl::terminate(), Terminator::Terminator(), CutMeshByLevelSetGeneratorBase::tet4ElemCutter(), ThreadedGeneralUserObject::threadJoin(), DiscreteElementUserObject::threadJoin(), GeneralUserObject::threadJoin(), Function::timeDerivative(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeExtremeValue::TimeExtremeValue(), Function::timeIntegral(), MooseLinearVariableFV< Real >::timeIntegratorError(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriodBase::TimePeriodBase(), VectorPostprocessorVisualizationAux::timestepSetup(), WebServerControl::toMiniJson(), MultiAppDofCopyTransfer::transfer(), MultiAppMFEMCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), TransformedPositions::TransformedPositions(), FEProblemBase::trustUserCouplingMatrix(), MooseVariableScalar::uDot(), MooseVariableScalar::uDotDot(), MooseVariableScalar::uDotDotOld(), FEProblemBase::uDotDotOldRequested(), MooseVariableScalar::uDotOld(), FEProblemBase::uDotOldRequested(), MooseBase::uniqueName(), Positions::unrollMultiDPositions(), ScalarKernelBase::uOld(), AuxScalarKernel::uOld(), Checkpoint::updateCheckpointFiles(), EqualValueBoundaryConstraint::updateConstrainedNodes(), SolutionUserObjectBase::updateExodusBracketingTimeIndices(), FEProblemBase::updateMaxQps(), MFEMHypreAMS::updateSolver(), MFEMHypreADS::updateSolver(), MFEMGMRESSolver::updateSolver(), MFEMCGSolver::updateSolver(), MFEMHypreFGMRES::updateSolver(), MFEMHyprePCG::updateSolver(), MFEMHypreGMRES::updateSolver(), MFEMSuperLU::updateSolver(), UpperBoundNodalKernel::UpperBoundNodalKernel(), NearestPointIntegralVariablePostprocessor::userObjectValue(), NearestPointAverage::userObjectValue(), BoundingBoxIC::value(), PiecewiseConstantFromCSV::value(), IntegralPreservingFunctionIC::value(), Axisymmetric2D3DSolutionFunction::value(), Function::value(), ValueRangeMarker::ValueRangeMarker(), ValueThresholdMarker::ValueThresholdMarker(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VariableTimeIntegrationAux::VariableTimeIntegrationAux(), AddVariableAction::variableType(), VariableValueVolumeHistogram::VariableValueVolumeHistogram(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), VectorNodalBC::VectorNodalBC(), SubProblem::vectorTagName(), SubProblem::vectorTagType(), MooseParsedGradFunction::vectorValue(), MooseParsedFunction::vectorValue(), Function::vectorValue(), SubProblem::verifyVectorTags(), ActionComponent::volume(), VTKOutput::VTKOutput(), WebServerControl::WebServerControl(), MooseApp::writeRestartableMetaData(), DOFMapOutput::writeStreamToFile(), and Console::writeStreamToFile().

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

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 321 of file MooseBase.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), PIDTransientControl::execute(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), DataFileInterface::getDataFilePath(), MultiAppTransfer::getPointInTargetAppFrame(), ImplicitMidpoint::ImplicitMidpoint(), ParsedDownSelectionPositions::initialize(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), NonlinearEigen::NonlinearEigen(), SolutionInvalidityOutput::output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramInfo(), ProjectionAux::ProjectionAux(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MFEMDataCollection::registerFields(), FEProblemBase::setRestartFile(), MooseApp::setupOptions(), SolutionUserObjectBase::SolutionUserObjectBase(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

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

mooseWarning() [1/2]

template<typename... Args>

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

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

Referenced by CopyMeshPartitioner::_do_partition(), AddKernelAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), addFunction(), MooseMesh::addPeriodicVariable(), DiracKernelBase::addPoint(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), SampledOutput::cloneMesh(), MultiAppGeneralFieldTransfer::closestToPosition(), VariableValueElementSubdomainModifier::computeSubdomainID(), GapValueAux::computeValue(), MultiApp::createApp(), DebugResidualAux::DebugResidualAux(), MeshDiagnosticsGenerator::diagnosticsLog(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), CartesianGridDivision::divisionIndex(), ElementMaterialSampler::ElementMaterialSampler(), Postprocessor::evaluateDotWarning(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), SubdomainPerElementGenerator::generate(), StitchMeshGenerator::generate(), ParsedGenerateSideset::generate(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), MFEMVectorFESpace::getFECName(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), LineValueSampler::getValue(), Terminator::handleMessage(), IndicatorMarker::IndicatorMarker(), SphericalGridDivision::initialize(), CylindricalGridDivision::initialize(), ElementGroupCentroidPositions::initialize(), CartesianGridDivision::initialize(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), BoundsBase::initialSetup(), ReferenceResidualConvergence::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MaterialOutputAction::outputHelper(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), Executioner::problem(), PropertyReadFile::readData(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MooseMesh::setCoordSystem(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), TimeDerivativeAux::TimeDerivativeAux(), Checkpoint::updateCheckpointFiles(), SampledOutput::updateSample(), PiecewiseConstantFromCSV::value(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

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

mooseWarning() [2/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.

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

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

mooseWarningNonPrefixed() [1/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");
  }

mooseWarningNonPrefixed() [2/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)...);
  }

mortarData() [1/2]

const MortarInterfaceWarehouse& FEProblemBase::mortarData ( ) const

inlineinherited

Returns the mortar data object.

Definition at line 2407 of file FEProblemBase.h.

{ return *_mortar_data; }

mortarData() [2/2]

MortarInterfaceWarehouse& FEProblemBase::mortarData ( )

inlineinherited

Definition at line 2408 of file FEProblemBase.h.

{ return *_mortar_data; }

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.

Referenced by AddElementalFieldAction::act(), CopyNodalVarsAction::act(), AdaptivityAction::act(), AddTimeStepperAction::act(), CSGOnlyAction::act(), DeprecatedBlockAction::act(), SetupTimeIntegratorAction::act(), AddActionComponentAction::act(), SetupResidualDebugAction::act(), DisplayGhostingAction::act(), MaterialOutputAction::act(), AddPeriodicBCAction::act(), FEProblemBase::addAnyRedistributers(), Executioner::addAttributeReporter(), addAuxKernel(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), DisplacedProblem::addAuxVariable(), addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), PhysicsComponentInterface::addComponent(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), Registry::addDataFilePath(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), MooseApp::addExecutor(), MooseApp::addExecutorParams(), addFESpace(), addFunction(), FEProblemBase::addFunction(), SubProblem::addFunctor(), addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FunctorMaterial::addFunctorProperty(), FunctorMaterial::addFunctorPropertyByBlocks(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), ADDGKernel::ADDGKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), addInitialCondition(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), DiffusionLHDGKernel::additionalROVariables(), IPHDGAssemblyHelper::additionalROVariables(), addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), ComponentMaterialPropertyInterface::addMaterials(), FEProblemBase::addMeshDivision(), MooseApp::addMeshGenerator(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), MeshGenerator::addMeshSubgenerator(), addMFEMPreconditioner(), addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), InitialConditionWarehouse::addObject(), FEProblemBase::addObject(), ComponentPhysicsInterface::addPhysics(), SubProblem::addPiecewiseByBlockLambdaFunctor(), addPostprocessor(), FEProblemBase::addPostprocessor(), InitialConditionBase::addPostprocessorDependencyHelper(), AuxKernelBase::addPostprocessorDependencyHelper(), UserObject::addPostprocessorDependencyHelper(), FEProblemBase::addPredictor(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), Action::addRelationshipManager(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), InitialConditionBase::addUserObjectDependencyHelper(), AuxKernelBase::addUserObjectDependencyHelper(), UserObject::addUserObjectDependencyHelper(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), AuxKernelBase::addVectorPostprocessorDependencyHelper(), UserObject::addVectorPostprocessorDependencyHelper(), MooseLinearVariableFV< Real >::adError(), Output::advancedExecuteOn(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), MooseVariableBase::allDofIndices(), MooseApp::appBinaryName(), MooseApp::appendMeshGenerator(), Registry::appNameFromAppPath(), MultiApp::appPostprocessorValue(), MultiApp::appProblem(), MultiApp::appProblemBase(), MultiApp::appUserObjectBase(), ArrayDGKernel::ArrayDGKernel(), ArrayParsedAux::ArrayParsedAux(), PhysicsBase::assignBlocks(), AStableDirk4::AStableDirk4(), AuxKernelBase::AuxKernelBase(), Function::average(), MultiApp::backup(), Boundary2DDelaunayGenerator::Boundary2DDelaunayGenerator(), CoarsenedPiecewiseLinear::buildCoarsenedGrid(), MFEMFESpace::buildFEC(), PiecewiseTabularBase::buildFromFile(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), MooseBase::callMooseError(), ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), PhysicsBase::checkBlockRestrictionIdentical(), PhysicsBase::checkComponentType(), ParsedConvergence::checkConvergence(), DefaultNonlinearConvergence::checkConvergence(), FEProblemBase::checkDependMaterialsHelper(), SamplerBase::checkForStandardFieldVariableType(), ReporterTransferInterface::checkHasReporterValue(), FEProblemBase::checkICRestartError(), Moose::Kokkos::Material::checkMaterialProperty(), Material::checkMaterialProperty(), MooseApp::checkMetaDataIntegrity(), Damper::checkMinDamping(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), Checkpoint::checkpointInfo(), DomainUserObject::checkVariable(), BlockRestrictable::checkVariable(), Coupleable::checkWritableVar(), 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(), CutMeshByPlaneGenerator::CutMeshByPlaneGenerator(), DebugResidualAux::DebugResidualAux(), MaterialBase::declareADProperty(), MeshGenerator::declareMeshesForSubByName(), MeshGenerator::declareNullMeshName(), MaterialBase::declareProperty(), DOFMapOutput::demangle(), DerivativeSumMaterialTempl< is_ad >::DerivativeSumMaterialTempl(), Registry::determineDataFilePath(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DomainUserObject::DomainUserObject(), DumpObjectsProblem::dumpObjectHelper(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementMaterialSampler::ElementMaterialSampler(), ElementValueSampler::ElementValueSampler(), EigenKernel::enabled(), MooseMesh::errorIfDistributedMesh(), SolutionUserObjectBase::evalMeshFunction(), SolutionUserObjectBase::evalMeshFunctionGradient(), SolutionUserObjectBase::evalMultiValuedMeshFunction(), SolutionUserObjectBase::evalMultiValuedMeshFunctionGradient(), SideValueSampler::execute(), RestartableDataReporter::execute(), GreaterThanLessThanPostprocessor::execute(), PointValue::execute(), MultiAppNearestNodeTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppUserObjectTransfer::execute(), WebServerControl::execute(), MultiAppGeneralFieldTransfer::execute(), ActionWarehouse::executeActionsWithAction(), Exodus::Exodus(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), MultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), PointSamplerBase::finalize(), ChainControl::fullControlDataName(), FunctionArrayAux::FunctionArrayAux(), FunctionDT::FunctionDT(), FunctionIC::functionName(), FVFunctionIC::functionName(), FunctorPositions::FunctorPositions(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVInitialConditionTempl< T >::FVInitialConditionTempl(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), GapValueAux::GapValueAux(), MooseServer::gatherDocumentSymbols(), BoundaryDeletionGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), BreakMeshByBlockGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), SideSetsFromNodeSetsGenerator::generate(), StitchBoundaryMeshGenerator::generate(), StitchMeshGenerator::generate(), ParsedExtraElementIDGenerator::generate(), XYDelaunayGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), InterfaceMaterial::getADMaterialProperty(), Material::getADMaterialProperty(), MultiAppTransfer::getAppInfo(), MultiApp::getBoundingBox(), MooseBase::getCheckedPointerParam(), MooseApp::getCheckpointDirectories(), Control::getControllableParameterByName(), Control::getControllableValue(), Control::getControllableValueByName(), FEProblemBase::getConvergence(), MeshGenerator::getCSGBase(), MeshGenerator::getCSGBasesByName(), Registry::getDataFilePath(), UserObject::getDependObjects(), DistributionInterface::getDistribution(), FEProblemBase::getDistribution(), DistributionInterface::getDistributionByName(), ElementUOProvider::getElementalValueLong(), ElementUOProvider::getElementalValueReal(), MultiApp::getExecutioner(), MooseApp::getExecutor(), FEProblemBase::getExecutor(), OutputWarehouse::getFileNumbers(), FEProblemBase::getFunction(), SubProblem::getFunctor(), NodalPatchRecovery::getGenericMaterialProperty(), InterfaceMaterial::getGenericMaterialProperty(), AuxKernelTempl< Real >::getGenericMaterialProperty(), Material::getGenericMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialProperty(), InterfaceMaterial::getGenericNeighborMaterialPropertyByName(), Material::getGenericOptionalMaterialProperty(), MaterialBase::getGenericZeroMaterialProperty(), getGridFunction(), SolutionUserObjectBase::getLocalVarIndex(), Marker::getMarkerValue(), Material::getMaterial(), FEProblemBase::getMaterial(), Material::getMaterialByName(), NodalPatchRecovery::getMaterialProperty(), InterfaceMaterial::getMaterialProperty(), AuxKernelTempl< Real >::getMaterialProperty(), Material::getMaterialProperty(), SubProblem::getMaterialPropertyBlockNames(), SubProblem::getMaterialPropertyBoundaryNames(), NodalPatchRecovery::getMaterialPropertyOld(), AuxKernelTempl< Real >::getMaterialPropertyOld(), InterfaceMaterial::getMaterialPropertyOld(), Material::getMaterialPropertyOld(), NodalPatchRecovery::getMaterialPropertyOlder(), AuxKernelTempl< Real >::getMaterialPropertyOlder(), InterfaceMaterial::getMaterialPropertyOlder(), Material::getMaterialPropertyOlder(), MFEMGeneralUserObject::getMatrixCoefficient(), MFEMGeneralUserObject::getMatrixCoefficientByName(), MeshGenerator::getMesh(), FEProblemBase::getMeshDivision(), MeshGenerator::getMeshesByName(), MooseApp::getMeshGenerator(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), ActionWarehouse::getMooseAppName(), MultiAppTransfer::getMultiApp(), InterfaceMaterial::getNeighborADMaterialProperty(), InterfaceMaterial::getNeighborMaterialProperty(), InterfaceMaterial::getNeighborMaterialPropertyOld(), InterfaceMaterial::getNeighborMaterialPropertyOlder(), MooseServer::getObjectParameters(), Material::getOptionalADMaterialProperty(), Material::getOptionalMaterialProperty(), Material::getOptionalMaterialPropertyOld(), Material::getOptionalMaterialPropertyOlder(), OutputWarehouse::getOutput(), MooseBase::getParam(), FEProblemBase::getPositionsObject(), FEProblemBase::getPostprocessorValueByName(), ComponentMaterialPropertyInterface::getPropertyValue(), ReporterData::getReporterInfo(), MooseApp::getRestartableDataMap(), MooseApp::getRestartableDataMapName(), MooseApp::getRestartableMetaData(), FEProblemBase::getSampler(), MFEMGeneralUserObject::getScalarCoefficient(), MFEMGeneralUserObject::getScalarCoefficientByName(), TimedSubdomainModifier::getSubdomainIDAndCheck(), TransientBase::getTimeStepperName(), ProjectedStatefulMaterialStorageAction::getTypeEnum(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), MFEMGeneralUserObject::getVectorCoefficient(), MFEMGeneralUserObject::getVectorCoefficientByName(), Terminator::handleMessage(), Control::hasControllableParameterByName(), FEProblemBase::hasConvergence(), FEProblemBase::hasFunction(), SubProblem::hasFunctor(), SubProblem::hasFunctorWithType(), MooseApp::hasMeshGenerator(), AdvancedOutput::hasOutputHelper(), FEProblemBase::hasPostprocessor(), FEProblemBase::hasPostprocessorValueByName(), MooseApp::hasRelationshipManager(), MooseApp::hasRestartableDataMap(), MooseApp::hasRestartableMetaData(), FEProblemBase::hasUserObject(), IterationAdaptiveDT::init(), AddVariableAction::init(), AdvancedOutput::init(), AdvancedOutput::initExecutionTypes(), AttribName::initFrom(), NestedDivision::initialize(), TransformedPositions::initialize(), BoundaryRestrictable::initializeBoundaryRestrictable(), JSONOutput::initialSetup(), SideFVFluxBCIntegral::initialSetup(), SolutionScalarAux::initialSetup(), MultiAppProjectionTransfer::initialSetup(), NodalVariableValue::initialSetup(), Console::initialSetup(), SolutionUserObjectBase::initialSetup(), AdvancedOutput::initOutputList(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), Function::integral(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), MeshGenerator::isChildMeshGenerator(), DerivativeMaterialInterface< MortarScalarBase >::isNotObjectVariable(), MeshGenerator::isNullMeshName(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MeshGenerator::isParentMeshGenerator(), LinearCombinationFunction::LinearCombinationFunction(), FEProblemBase::logAdd(), MooseLinearVariableFV< Real >::lowerDError(), Marker::Marker(), MaterialBase::markMatPropRequested(), MatDiffusionBase< Real >::MatDiffusionBase(), Material::Material(), MaterialDerivativeTestKernelBase< Real >::MaterialDerivativeTestKernelBase(), Distribution::median(), MemoryUsageReporter::MemoryUsageReporter(), MeshGenerator::meshPropertyPrefix(), MooseBase::messagePrefix(), OutputWarehouse::mooseConsole(), SolutionInvalidInterface::mooseDeprecated(), MooseVariableBase::MooseVariableBase(), MooseVariableInterface< Real >::MooseVariableInterface(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), MooseLinearVariableFV< Real >::nodalError(), NodalPatchRecoveryAuxBase::NodalPatchRecoveryAuxBase(), NodalValueSampler::NodalValueSampler(), Registry::objData(), MeshGenerator::Comparator::operator()(), ProgressOutput::output(), DOFMapOutput::output(), Output::Output(), AdvancedOutput::outputElementalVariables(), ConsoleUtils::outputExecutionInformation(), MaterialOutputAction::outputHelper(), AdvancedOutput::outputInput(), AdvancedOutput::outputNodalVariables(), Exodus::outputPostprocessors(), AdvancedOutput::outputPostprocessors(), TableOutput::outputReporter(), AdvancedOutput::outputReporters(), AdvancedOutput::outputScalarVariables(), AdvancedOutput::outputSystemInformation(), AdvancedOutput::outputVectorPostprocessors(), SolutionInvalidInterface::paramWarning(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedODEKernel::ParsedODEKernel(), ComponentPhysicsInterface::physicsExists(), PiecewiseBilinear::PiecewiseBilinear(), PiecewiseByBlockFunctorMaterialTempl< T >::PiecewiseByBlockFunctorMaterialTempl(), MooseApp::possiblyLoadRestartableMetaData(), PhysicsBase::prefix(), MooseMesh::prepare(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), PerfGraphLivePrint::printStats(), FEProblemBase::projectInitialConditionOnCustomRange(), MooseBase::queryParam(), MultiApp::readCommandLineArguments(), Receiver::Receiver(), Executor::Result::record(), AppFactory::reg(), Registry::registerObjectsTo(), 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(), NodeSetsGeneratorBase::setup(), Split::setup(), SideSetsGeneratorBase::setup(), TransientMultiApp::setupApp(), FullSolveMultiApp::showStatusMessage(), SideSetExtruderGenerator::SideSetExtruderGenerator(), TransientMultiApp::solveStep(), UserObject::spatialValue(), WebServerControl::startServer(), StitchedMesh::StitchedMesh(), SubProblem::storeBoundaryDelayedCheckMatProp(), SubProblem::storeBoundaryMatPropName(), MaterialBase::storeBoundaryZeroMatProp(), SubProblem::storeBoundaryZeroMatProp(), SubProblem::storeSubdomainDelayedCheckMatProp(), SubProblem::storeSubdomainMatPropName(), MaterialBase::storeSubdomainZeroMatProp(), SubProblem::storeSubdomainZeroMatProp(), ConstraintWarehouse::subdomainsCovered(), MaterialBase::subdomainSetup(), TaggingInterface::TaggingInterface(), MooseLinearVariableFV< Real >::timeIntegratorError(), VectorPostprocessorVisualizationAux::timestepSetup(), ElementSubdomainModifierBase::timestepSetup(), to_json(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), TransientMultiApp::TransientMultiApp(), MooseServer::traverseParseTreeAndFillSymbols(), MooseBase::typeAndName(), MooseBase::uniqueParameterName(), FVFluxBC::uOnGhost(), FVFluxBC::uOnUSub(), UserObject::UserObject(), UserObjectInterface::userObjectName(), ParsedAux::validateGenericVectorNames(), PhysicsBase::variableExists(), MultiAppTransfer::variableIntegrityCheck(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), Convergence::verboseOutput(), AdvancedOutput::wantOutput(), Coupleable::writableCoupledValue(), Coupleable::writableVariable(), Console::write(), and MooseApp::writeRestartableMetaData().

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

needBoundaryMaterialOnSide()

bool FEProblemBase::needBoundaryMaterialOnSide ( BoundaryID  bnd_id, const THREAD_ID  tid  )

inherited

These methods are used to determine whether stateful material properties need to be stored on internal sides.

There are five situations where this may be the case: 1) DGKernels 2) IntegratedBCs 3)InternalSideUserObjects 4)ElementalAuxBCs 5)InterfaceUserObjects

Method 1:

Parameters

bnd_id	the boundary id for which to see if stateful material properties need to be stored
tid	the THREAD_ID of the caller

Returns

Boolean indicating whether material properties need to be stored

Method 2:

Parameters

subdomain_id	the subdomain id for which to see if stateful material properties need to be stored
tid	the THREAD_ID of the caller

Returns

Boolean indicating whether material properties need to be stored

Definition at line 8933 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::onBoundary(), ProjectMaterialProperties::onBoundary(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFaceOnBoundary(), and FEProblemBase::reinitMaterialsNeighborOnBoundary().

{
  if (_bnd_mat_side_cache[tid].find(bnd_id) == _bnd_mat_side_cache[tid].end())
  {
    auto & bnd_mat_side_cache = _bnd_mat_side_cache[tid][bnd_id];
    bnd_mat_side_cache = false;

    // Check systems
    if (_aux->needMaterialOnSide(bnd_id))
    {
      bnd_mat_side_cache = true;
      return true;
    }
    for (auto & nl : _nl)
      if (nl->needBoundaryMaterialOnSide(bnd_id, tid))
      {
        bnd_mat_side_cache = true;
        return true;
      }

    // TODO: these objects should be checked for whether they actually consume materials
    // NOTE: InterfaceUO can use use boundary properties too
    if (theWarehouse()
            .query()
            .condition<AttribThread>(tid)
            .condition<AttribInterfaces>(Interfaces::SideUserObject | Interfaces::DomainUserObject |
                                         Interfaces::InterfaceUserObject)
            .condition<AttribBoundaries>(bnd_id)
            .count() > 0)
    {
      bnd_mat_side_cache = true;
      return true;
    }
  }

  return _bnd_mat_side_cache[tid][bnd_id];
}

needFV()

virtual void FEProblemBase::needFV ( )

inlineoverridevirtualinherited

marks this problem as including/needing finite volume functionality.

Implements SubProblem.

Definition at line 2672 of file FEProblemBase.h.

Referenced by DiffusionFV::initializePhysicsAdditional(), and DisplacedProblem::needFV().

{ _have_fv = true; }

needInterfaceMaterialOnSide()

bool FEProblemBase::needInterfaceMaterialOnSide ( BoundaryID  bnd_id, const THREAD_ID  tid  )

inherited

Definition at line 8972 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::onInterface(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsInterface(), and FEProblemBase::reinitMaterialsNeighborOnBoundary().

{
  if (_interface_mat_side_cache[tid].find(bnd_id) == _interface_mat_side_cache[tid].end())
  {
    auto & interface_mat_side_cache = _interface_mat_side_cache[tid][bnd_id];
    interface_mat_side_cache = false;

    // Aux-system has not needed interface materials so far
    for (auto & nl : _nl)
      if (nl->needInterfaceMaterialOnSide(bnd_id, tid))
      {
        interface_mat_side_cache = true;
        return true;
      }

    // TODO: these objects should be checked for whether they actually consume materials
    if (theWarehouse()
            .query()
            .condition<AttribThread>(tid)
            .condition<AttribInterfaces>(Interfaces::InterfaceUserObject |
                                         Interfaces::DomainUserObject)
            .condition<AttribBoundaries>(bnd_id)
            .count() > 0)
    {
      interface_mat_side_cache = true;
      return true;
    }
    else if (_interface_materials.hasActiveBoundaryObjects(bnd_id, tid))
    {
      interface_mat_side_cache = true;
      return true;
    }
  }
  return _interface_mat_side_cache[tid][bnd_id];
}

needInternalNeighborSideMaterial()

bool FEProblemBase::needInternalNeighborSideMaterial ( SubdomainID  subdomain_id, const THREAD_ID  tid  )

inherited

Definition at line 9009 of file FEProblemBase.C.

Referenced by FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsNeighborOnBoundary(), ComputeMaterialsObjectThread::subdomainChanged(), and ProjectMaterialProperties::subdomainChanged().

{
  if (_block_mat_side_cache[tid].find(subdomain_id) == _block_mat_side_cache[tid].end())
  {
    _block_mat_side_cache[tid][subdomain_id] = false;

    for (auto & nl : _nl)
      if (nl->needInternalNeighborSideMaterial(subdomain_id, tid))
      {
        _block_mat_side_cache[tid][subdomain_id] = true;
        return true;
      }

    // TODO: these objects should be checked for whether they actually consume materials
    if (theWarehouse()
            .query()
            .condition<AttribThread>(tid)
            .condition<AttribInterfaces>(Interfaces::InternalSideUserObject |
                                         Interfaces::DomainUserObject)
            .condition<AttribSubdomains>(subdomain_id)
            .count() > 0)
    {
      _block_mat_side_cache[tid][subdomain_id] = true;
      return true;
    }
  }

  return _block_mat_side_cache[tid][subdomain_id];
}

needSolutionState()

void FEProblemBase::needSolutionState ( unsigned int  oldest_needed, Moose::SolutionIterationType  iteration_type  )

inherited

Declare that we need up to old (1) or older (2) solution states for a given type of iteration.

Parameters

oldest_needed	oldest solution state needed
iteration_type	the type of iteration for which old/older states are needed

Definition at line 738 of file FEProblemBase.C.

Referenced by FEProblemBase::createTagSolutions().

{
  for (auto & sys : _solver_systems)
    sys->needSolutionState(state, iteration_type);
  _aux->needSolutionState(state, iteration_type);
}

needsPreviousNewtonIteration() [1/2]

void FEProblemBase::needsPreviousNewtonIteration ( bool  state )

inherited

Set a flag that indicated that user required values for the previous Newton iterate.

Definition at line 9046 of file FEProblemBase.C.

Referenced by Coupleable::coupledGradientPreviousNL(), Coupleable::coupledNodalValuePreviousNL(), Coupleable::coupledSecondPreviousNL(), Coupleable::coupledValuePreviousNL(), and NonlinearSystem::solve().

{
  if (state && !vectorTagExists(Moose::PREVIOUS_NL_SOLUTION_TAG))
    mooseError("Previous nonlinear solution is required but not added through "
               "Problem/previous_nl_solution_required=true");
}

needsPreviousNewtonIteration() [2/2]

bool FEProblemBase::needsPreviousNewtonIteration ( ) const

inherited

Check to see whether we need to compute the variable values of the previous Newton iterate.

Returns

true if the user required values of the previous Newton iterate

Definition at line 9040 of file FEProblemBase.C.

{
  return vectorTagExists(Moose::PREVIOUS_NL_SOLUTION_TAG);
}

needToAddDefaultMultiAppFixedPointConvergence()

bool FEProblemBase::needToAddDefaultMultiAppFixedPointConvergence ( ) const

inlineinherited

Returns true if the problem needs to add the default fixed point convergence.

Definition at line 669 of file FEProblemBase.h.

  {
    return _need_to_add_default_multiapp_fixed_point_convergence;
  }

needToAddDefaultNonlinearConvergence()

bool FEProblemBase::needToAddDefaultNonlinearConvergence ( ) const

inlineinherited

Returns true if the problem needs to add the default nonlinear convergence.

Definition at line 664 of file FEProblemBase.h.

  {
    return _need_to_add_default_nonlinear_convergence;
  }

needToAddDefaultSteadyStateConvergence()

bool FEProblemBase::needToAddDefaultSteadyStateConvergence ( ) const

inlineinherited

Returns true if the problem needs to add the default steady-state detection convergence.

Definition at line 674 of file FEProblemBase.h.

  {
    return _need_to_add_default_steady_state_convergence;
  }

neighborSubdomainSetup()

void FEProblemBase::neighborSubdomainSetup ( SubdomainID  subdomain, const THREAD_ID  tid  )

virtualinherited

Definition at line 2536 of file FEProblemBase.C.

Referenced by ThreadedFaceLoop< RangeType >::neighborSubdomainChanged().

{
  _all_materials.neighborSubdomainSetup(subdomain, tid);
}

newAssemblyArray()

void FEProblemBase::newAssemblyArray ( std::vector< std::shared_ptr< SolverSystem >> &  solver_systems )

virtualinherited

Definition at line 746 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), ExternalProblem::ExternalProblem(), and FEProblem::FEProblem().

{
  unsigned int n_threads = libMesh::n_threads();

  _assembly.resize(n_threads);
  for (const auto i : make_range(n_threads))
  {
    _assembly[i].resize(solver_systems.size());
    for (const auto j : index_range(solver_systems))
      _assembly[i][j] = std::make_unique<Assembly>(*solver_systems[j], i);
  }
}

nlConverged()

bool SubProblem::nlConverged ( const unsigned int  nl_sys_num )

virtualinherited

Returns

whether the given nonlinear system nl_sys_num is converged.

Definition at line 717 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 FEProblemBase::nLinearIterations ( const unsigned int  nl_sys_num ) const

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6810 of file FEProblemBase.C.

Referenced by PiecewiseLinearFromVectorPostprocessor::valueInternal().

{
  return _nl[nl_sys_num]->nLinearIterations();
}

nlSysNum()

unsigned int FEProblemBase::nlSysNum ( const NonlinearSystemName &  nl_sys_name ) const

overridevirtualinherited

Returns

the nonlinear system number corresponding to the provided nl_sys_name

Implements SubProblem.

Definition at line 6540 of file FEProblemBase.C.

Referenced by DisplacedProblem::nlSysNum().

{
  std::istringstream ss(nl_sys_name);
  unsigned int nl_sys_num;
  if (!(ss >> nl_sys_num) || !ss.eof())
    nl_sys_num = libmesh_map_find(_nl_sys_name_to_num, nl_sys_name);

  return nl_sys_num;
}

nNonlinearIterations()

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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6804 of file FEProblemBase.C.

Referenced by PiecewiseLinearFromVectorPostprocessor::valueInternal().

{
  return _nl[nl_sys_num]->nNonlinearIterations();
}

nonlocalCouplingEntries()

std::vector< std::pair< MooseVariableFEBase *, MooseVariableFEBase * > > & FEProblemBase::nonlocalCouplingEntries ( const THREAD_ID  tid, const unsigned int  nl_sys_num  )

inherited

Definition at line 6392 of file FEProblemBase.C.

Referenced by ComputeFullJacobianThread::computeOnBoundary(), and ComputeFullJacobianThread::computeOnElement().

{
  return _assembly[tid][nl_sys]->nonlocalCouplingEntries();
}

nonlocalCouplingMatrix()

const libMesh::CouplingMatrix & FEProblemBase::nonlocalCouplingMatrix ( const unsigned  i ) const

overridevirtualinherited

Returns

the nonlocal coupling matrix for the i'th nonlinear system

Implements SubProblem.

Definition at line 9685 of file FEProblemBase.C.

Referenced by DisplacedProblem::nonlocalCouplingMatrix().

{
  return _nonlocal_cm[i];
}

notifyWhenMeshChanges()

void FEProblemBase::notifyWhenMeshChanges ( MeshChangedInterface *  mci )

inherited

Register an object that derives from MeshChangedInterface to be notified when the mesh changes.

Definition at line 8466 of file FEProblemBase.C.

Referenced by MeshChangedInterface::MeshChangedInterface().

{
  _notify_when_mesh_changes.push_back(mci);
}

notifyWhenMeshDisplaces()

void FEProblemBase::notifyWhenMeshDisplaces ( MeshDisplacedInterface *  mdi )

inherited

Register an object that derives from MeshDisplacedInterface to be notified when the displaced mesh gets updated.

Definition at line 8472 of file FEProblemBase.C.

Referenced by MeshDisplacedInterface::MeshDisplacedInterface().

{
  _notify_when_mesh_displaces.push_back(mdi);
}

numGridSteps()

void FEProblemBase::numGridSteps ( unsigned int  num_grid_steps )

inlineinherited

Set the number of steps in a grid sequences.

Definition at line 2429 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

{ _num_grid_steps = num_grid_steps; }

numLinearSystems()

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

inlineoverridevirtualinherited

Returns

the number of linear systems in the problem

Implements SubProblem.

Definition at line 2578 of file FEProblemBase.h.

Referenced by IterationAdaptiveDT::acceptStep(), FEProblemBase::addPredictor(), IterationAdaptiveDT::computeAdaptiveDT(), FEProblemSolve::FEProblemSolve(), EigenProblem::init(), Console::meshChanged(), DisplacedProblem::numLinearSystems(), Console::outputSystemInformation(), Moose::PetscSupport::petscSetDefaults(), and FEProblemBase::setLinearConvergenceNames().

{ return _num_linear_sys; }

numMatrixTags()

virtual unsigned int SubProblem::numMatrixTags ( ) const

inlinevirtualinherited

The total number of tags.

Reimplemented in DisplacedProblem.

Definition at line 248 of file SubProblem.h.

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

{ return _matrix_tag_name_to_tag_id.size(); }

numNonlinearSystems()

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

inlineoverridevirtualinherited

Returns

the number of nonlinear systems in the problem

Implements SubProblem.

Definition at line 2576 of file FEProblemBase.h.

Referenced by IterationAdaptiveDT::acceptStep(), FEProblemBase::addPredictor(), DisplacedProblem::addTimeIntegrator(), DisplacedProblem::DisplacedProblem(), Executioner::Executioner(), EigenProblem::init(), FEProblemBase::jacobianSetup(), PNGOutput::makeMeshFunc(), Console::meshChanged(), DisplacedProblem::numNonlinearSystems(), ComputeBoundaryInitialConditionThread::onNode(), BoundaryElemIntegrityCheckThread::operator()(), ConsoleUtils::outputExecutionInformation(), Console::outputSystemInformation(), Moose::PetscSupport::petscSetDefaults(), ReferenceResidualConvergence::ReferenceResidualConvergence(), FEProblemBase::residualSetup(), Moose::SlepcSupport::setEigenProblemSolverParams(), Moose::PetscSupport::setLineSearchFromParams(), Moose::PetscSupport::setMFFDTypeFromParams(), FEProblemBase::setNonlinearConvergenceNames(), Moose::PetscSupport::setSolveTypeFromParams(), FEProblemSolve::solve(), FEProblemBase::solveLinearSystem(), Moose::SlepcSupport::storeSolveType(), and Console::writeVariableNorms().

{ return _num_nl_sys; }

numSolverSystems()

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

inlineoverridevirtualinherited

Returns

the number of solver systems in the problem

Implements SubProblem.

Definition at line 2580 of file FEProblemBase.h.

Referenced by ElementSubdomainModifierBase::applyIC(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), Eigenvalue::Eigenvalue(), FEProblemBase::FEProblemBase(), TransientBase::getTimeIntegratorNames(), DisplacedProblem::numSolverSystems(), ConsoleUtils::outputExecutionInformation(), Moose::PetscSupport::petscSetDefaultKSPNormType(), Moose::PetscSupport::petscSetDefaultPCSide(), and FEProblemBase::solverParams().

{ return _num_nl_sys + _num_linear_sys; }

numVectorTags()

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

virtualinherited

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

Reimplemented in DisplacedProblem.

Definition at line 196 of file SubProblem.C.

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

{
  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");

  return getVectorTags(type).size();
}

objectExecuteHelper()

template<typename T >

void FEProblemBase::objectExecuteHelper ( const std::vector< T *> &  objects )

staticinherited

Definition at line 3400 of file FEProblemBase.h.

{
  for (T * obj_ptr : objects)
    obj_ptr->execute();
}

objectSetupHelper()

template<typename T >

void FEProblemBase::objectSetupHelper ( const std::vector< T *> &  objects, const ExecFlagType &  exec_flag  )

staticinherited

Helpers for calling the necessary setup/execute functions for the supplied objects.

Definition at line 3366 of file FEProblemBase.h.

{
  if (exec_flag == EXEC_INITIAL)
  {
    for (T * obj_ptr : objects)
      obj_ptr->initialSetup();
  }

  else if (exec_flag == EXEC_TIMESTEP_BEGIN)
  {
    for (const auto obj_ptr : objects)
      obj_ptr->timestepSetup();
  }
  else if (exec_flag == EXEC_SUBDOMAIN)
  {
    for (const auto obj_ptr : objects)
      obj_ptr->subdomainSetup();
  }

  else if (exec_flag == EXEC_NONLINEAR)
  {
    for (const auto obj_ptr : objects)
      obj_ptr->jacobianSetup();
  }

  else if (exec_flag == EXEC_LINEAR)
  {
    for (const auto obj_ptr : objects)
      obj_ptr->residualSetup();
  }
}

onlyAllowDefaultNonlinearConvergence()

virtual bool FEProblemBase::onlyAllowDefaultNonlinearConvergence ( ) const

inlinevirtualinherited

Returns true if an error will result if the user supplies 'nonlinear_convergence'.

Some problems are strongly tied to their convergence, and it does not make sense to use any convergence other than their default and additionally would be error-prone.

Reimplemented in ReferenceResidualProblem.

Definition at line 718 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

{ return false; }

onTimestepBegin()

void FEProblemBase::onTimestepBegin ( )

overridevirtualinherited

Implements SubProblem.

Definition at line 6964 of file FEProblemBase.C.

Referenced by MFEMTransient::takeStep(), and TransientBase::takeStep().

{
  TIME_SECTION("onTimestepBegin", 2);

  for (auto & nl : _nl)
    nl->onTimestepBegin();
}

onTimestepEnd()

void FEProblemBase::onTimestepEnd ( )

overridevirtualinherited

Implements SubProblem.

Reimplemented in DumpObjectsProblem.

Definition at line 6973 of file FEProblemBase.C.

Referenced by NonlinearEigen::init(), EigenExecutionerBase::init(), MFEMProblemSolve::solve(), FixedPointSolve::solveStep(), NonlinearEigen::takeStep(), and InversePowerMethod::takeStep().

{
}

outputStep()

void FEProblemBase::outputStep ( ExecFlagType  type )

virtualinherited

Output the current step.

Will ensure that everything is in the proper state to be outputted. Then tell the OutputWarehouse to do its thing

Parameters

type	The type execution flag (see Moose.h)

Reimplemented in DumpObjectsProblem.

Definition at line 6927 of file FEProblemBase.C.

Referenced by TransientBase::endStep(), MFEMSteady::execute(), SteadyBase::execute(), TransientBase::execute(), Eigenvalue::execute(), InversePowerMethod::init(), NonlinearEigen::init(), EigenExecutionerBase::postExecute(), TransientBase::preExecute(), MFEMProblemSolve::solve(), FixedPointSolve::solve(), TransientMultiApp::solveStep(), and FixedPointSolve::solveStep().

{
  TIME_SECTION("outputStep", 1, "Outputting");

  setCurrentExecuteOnFlag(type);

  for (auto & sys : _solver_systems)
    sys->update();
  _aux->update();

  if (_displaced_problem)
    _displaced_problem->syncSolutions();
  _app.getOutputWarehouse().outputStep(type);

  setCurrentExecuteOnFlag(EXEC_NONE);
}

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 439 of file MooseBase.h.

Referenced by HierarchicalGridPartitioner::_do_partition(), AutoCheckpointAction::act(), SetupDebugAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), NEML2ModelExecutor::addGatheredParameter(), NEML2ModelExecutor::addGatheredVariable(), ADDGKernel::ADDGKernel(), CylinderComponent::addMeshGenerators(), AddPeriodicBCAction::AddPeriodicBCAction(), ReporterPointSource::addPoints(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADKernelTempl< T >::ADKernelTempl(), ADNodalKernel::ADNodalKernel(), ADPenaltyPeriodicSegmentalConstraint::ADPenaltyPeriodicSegmentalConstraint(), ADPeriodicSegmentalConstraint::ADPeriodicSegmentalConstraint(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), AdvectiveFluxAux::AdvectiveFluxAux(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), ArrayBodyForce::ArrayBodyForce(), ArrayDGKernel::ArrayDGKernel(), ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayDirichletBC::ArrayDirichletBC(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), ArrayParsedAux::ArrayParsedAux(), ArrayPenaltyDirichletBC::ArrayPenaltyDirichletBC(), ArrayVacuumBC::ArrayVacuumBC(), ArrayVarReductionAux::ArrayVarReductionAux(), ParsedSubdomainIDsGenerator::assignElemSubdomainID(), AuxKernelBase::AuxKernelBase(), BatchMeshGeneratorAction::BatchMeshGeneratorAction(), BlockDeletionGenerator::BlockDeletionGenerator(), BlockWeightedPartitioner::BlockWeightedPartitioner(), BoundsBase::BoundsBase(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), BuildArrayVariableAux::BuildArrayVariableAux(), PiecewiseTabularBase::buildFromFile(), MFEMMesh::buildMesh(), CartesianGridDivision::CartesianGridDivision(), checkComponent(), MeshGenerator::checkGetMesh(), ComponentInitialConditionInterface::checkInitialConditionsAllRequested(), BatchMeshGeneratorAction::checkInputParameterType(), PhysicsBase::checkIntegrityEarly(), PostprocessorInterface::checkParam(), FEProblemBase::checkProblemIntegrity(), MultiAppReporterTransfer::checkSiblingsTransferSupported(), Coupleable::checkVar(), MultiAppTransfer::checkVariable(), CircularBoundaryCorrectionGenerator::CircularBoundaryCorrectionGenerator(), CircularBoundaryCorrectionGenerator::circularCenterCalculator(), MultiAppGeneralFieldTransfer::closestToPosition(), CoarsenBlockGenerator::CoarsenBlockGenerator(), CombinerGenerator::CombinerGenerator(), ComponentInitialConditionInterface::ComponentInitialConditionInterface(), ComponentMaterialPropertyInterface::ComponentMaterialPropertyInterface(), CompositionDT::CompositionDT(), FunctorAux::computeValue(), ConcentricCircleMeshGenerator::ConcentricCircleMeshGenerator(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< false >::ConservativeAdvectionBCTempl(), ConservativeAdvectionTempl< is_ad >::ConservativeAdvectionTempl(), ConstantVectorPostprocessor::ConstantVectorPostprocessor(), ContainsPointAux::ContainsPointAux(), CopyValueAux::CopyValueAux(), Coupleable::Coupleable(), CoupledForceTempl< is_ad >::CoupledForceTempl(), CoupledValueFunctionMaterialTempl< is_ad >::CoupledValueFunctionMaterialTempl(), MultiApp::createApp(), MeshGeneratorSystem::createMeshGenerator(), CylindricalGridDivision::CylindricalGridDivision(), DebugResidualAux::DebugResidualAux(), ConstantReporter::declareConstantReporterValue(), ConstantReporter::declareConstantReporterValues(), AccumulateReporter::declareLateValues(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DGKernel::DGKernel(), DGKernelBase::DGKernelBase(), DGLowerDKernel::DGLowerDKernel(), DiffusionFluxAux::DiffusionFluxAux(), DomainUserObject::DomainUserObject(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), ElementAdaptivityLevelAux::ElementAdaptivityLevelAux(), ElementGroupCentroidPositions::ElementGroupCentroidPositions(), ElementLengthAux::ElementLengthAux(), ElementLpNormAux::ElementLpNormAux(), ExtraIDIntegralVectorPostprocessor::elementValue(), ElementValueSampler::ElementValueSampler(), ElementVectorL2Error::ElementVectorL2Error(), EqualValueEmbeddedConstraintTempl< is_ad >::EqualValueEmbeddedConstraintTempl(), ReporterPointSource::errorCheck(), StitchMeshGeneratorBase::errorMissingBoundary(), ExamplePatchMeshGenerator::ExamplePatchMeshGenerator(), MultiAppNearestNodeTransfer::execute(), MultiAppUserObjectTransfer::execute(), ExtraElementIDAux::ExtraElementIDAux(), ExtraElementIntegerDivision::ExtraElementIntegerDivision(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), FEProblemBase::FEProblemBase(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::FileMeshGenerator(), FillBetweenCurvesGenerator::FillBetweenCurvesGenerator(), FillBetweenSidesetsGenerator::FillBetweenSidesetsGenerator(), ReporterPointSource::fillPoint(), SpatialUserObjectVectorPostprocessor::fillPoints(), CombinerGenerator::fillPositions(), MultiApp::fillPositions(), InternalSideIndicatorBase::finalize(), 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(), FunctorPositions::FunctorPositions(), FunctorVectorElementalAuxTempl< is_ad >::FunctorVectorElementalAuxTempl(), FVAdvection::FVAdvection(), FVFluxBC::FVFluxBC(), FVInterfaceKernel::FVInterfaceKernel(), FVOneVarDiffusionInterface::FVOneVarDiffusionInterface(), FVTwoVarContinuityConstraint::FVTwoVarContinuityConstraint(), Boundary2DDelaunayGenerator::General2DDelaunay(), BoundaryDeletionGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), AddMetaDataGenerator::generate(), BlockToMeshConverterGenerator::generate(), BreakBoundaryOnSubdomainGenerator::generate(), ElementsToTetrahedronsConverter::generate(), ExtraNodesetGenerator::generate(), FillBetweenCurvesGenerator::generate(), FillBetweenSidesetsGenerator::generate(), LowerDBlockFromSidesetGenerator::generate(), PlaneIDMeshGenerator::generate(), RenameBlockGenerator::generate(), RenameBoundaryGenerator::generate(), BlockDeletionGenerator::generate(), Boundary2DDelaunayGenerator::generate(), BoundaryElementConversionGenerator::generate(), BreakMeshByBlockGenerator::generate(), CoarsenBlockGenerator::generate(), FlipSidesetGenerator::generate(), GeneratedMeshGenerator::generate(), ParsedSubdomainGeneratorBase::generate(), RefineBlockGenerator::generate(), RefineSidesetGenerator::generate(), SideSetsFromNodeSetsGenerator::generate(), AdvancedExtruderGenerator::generate(), BreakMeshByElementGenerator::generate(), CombinerGenerator::generate(), MeshCollectionGenerator::generate(), MeshExtruderGenerator::generate(), ParsedCurveGenerator::generate(), ParsedExtraElementIDGenerator::generate(), StackGenerator::generate(), XYZDelaunayGenerator::generate(), CircularBoundaryCorrectionGenerator::generate(), CutMeshByLevelSetGeneratorBase::generate(), XYDelaunayGenerator::generate(), XYMeshLineCutter::generate(), PatternedMeshGenerator::generate(), SubdomainBoundingBoxGenerator::generate(), GeneratedMeshGenerator::GeneratedMeshGenerator(), 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(), Sampler::getNextLocalRow(), FEProblemSolve::getParamFromNonlinearSystemVectorParam(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), MultiAppNearestNodeTransfer::getTargetLocalNodes(), UserObjectInterface::getUserObjectBase(), UserObjectInterface::getUserObjectName(), HFEMDirichletBC::HFEMDirichletBC(), AddVariableAction::init(), MultiApp::init(), DistributedPositions::initialize(), BlockWeightedPartitioner::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), PhysicsBase::initializePhysics(), JSONOutput::initialSetup(), MultiAppCloneReporterTransfer::initialSetup(), SolutionIC::initialSetup(), SideFVFluxBCIntegral::initialSetup(), MultiAppVariableValueSamplePostprocessorTransfer::initialSetup(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), HistogramVectorPostprocessor::initialSetup(), ReferenceResidualConvergence::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), LibtorchControlValuePostprocessor::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), ElementSubdomainModifierBase::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(), KokkosBoundNodalKernel< KokkosUpperBoundNodalKernel >::KokkosBoundNodalKernel(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), LinearCombinationFunction::LinearCombinationFunction(), LinearFVAdvectionDiffusionFunctorRobinBC::LinearFVAdvectionDiffusionFunctorRobinBC(), LowerDIntegratedBC::LowerDIntegratedBC(), PNGOutput::makeMeshFunc(), MatCoupledForce::MatCoupledForce(), MaterialADConverterTempl< T >::MaterialADConverterTempl(), MaterialFunctorConverterTempl< T >::MaterialFunctorConverterTempl(), MatrixSymmetryCheck::MatrixSymmetryCheck(), PatternedMeshGenerator::mergeSubdomainNameMaps(), MeshCollectionGenerator::MeshCollectionGenerator(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MeshDivisionAux::MeshDivisionAux(), MeshGenerator::MeshGenerator(), MeshGeneratorComponent::MeshGeneratorComponent(), MFEMGenericFunctorMaterial::MFEMGenericFunctorMaterial(), MFEMGenericFunctorVectorMaterial::MFEMGenericFunctorVectorMaterial(), MFEMSumAux::MFEMSumAux(), MooseLinearVariableFV< Real >::MooseLinearVariableFV(), UserObjectInterface::mooseObjectError(), MoosePreconditioner::MoosePreconditioner(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), MooseVariableBase::MooseVariableBase(), MortarConstraintBase::MortarConstraintBase(), MortarNodalAuxKernelTempl< ComputeValueType >::MortarNodalAuxKernelTempl(), MultiApp::moveApp(), MoveNodeGenerator::MoveNodeGenerator(), MultiApp::MultiApp(), MultiAppCloneReporterTransfer::MultiAppCloneReporterTransfer(), MultiAppGeneralFieldNearestLocationTransfer::MultiAppGeneralFieldNearestLocationTransfer(), 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(), NestedDivision::NestedDivision(), NodalBC::NodalBC(), NodalEqualValueConstraint::NodalEqualValueConstraint(), NodalKernel::NodalKernel(), NodalPatchRecoveryAux::NodalPatchRecoveryAux(), NodalValueSampler::NodalValueSampler(), Output::Output(), ParsedCurveGenerator::ParsedCurveGenerator(), ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl(), ParsedPostprocessor::ParsedPostprocessor(), ParsedReporterBase::ParsedReporterBase(), ParsedScalarReporter::ParsedScalarReporter(), ParsedVectorRealReductionReporter::ParsedVectorRealReductionReporter(), ParsedVectorReporter::ParsedVectorReporter(), ParsedVectorVectorRealReductionReporter::ParsedVectorVectorRealReductionReporter(), PatternedMeshGenerator::PatternedMeshGenerator(), PenaltyPeriodicSegmentalConstraint::PenaltyPeriodicSegmentalConstraint(), PeriodicSegmentalConstraint::PeriodicSegmentalConstraint(), PIDTransientControl::PIDTransientControl(), PlaneDeletionGenerator::PlaneDeletionGenerator(), PlaneIDMeshGenerator::PlaneIDMeshGenerator(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), PolyLineMeshGenerator::PolyLineMeshGenerator(), ReporterInterface::possiblyCheckHasReporter(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), LibmeshPartitioner::prepareBlocksForSubdomainPartitioner(), ProjectedMaterialPropertyNodalPatchRecoveryAux::ProjectedMaterialPropertyNodalPatchRecoveryAux(), ProjectionAux::ProjectionAux(), PropertyReadFile::PropertyReadFile(), RandomIC::RandomIC(), MultiApp::readCommandLineArguments(), PropertyReadFile::readData(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), RefineBlockGenerator::RefineBlockGenerator(), RefineSidesetGenerator::RefineSidesetGenerator(), RenameBlockGenerator::RenameBlockGenerator(), RenameBoundaryGenerator::RenameBoundaryGenerator(), ReporterPointSource::ReporterPointSource(), FEProblemBase::restoreSolutions(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), FEProblemBase::setLinearConvergenceNames(), FEProblemBase::setNonlinearConvergenceNames(), MooseMesh::setPartitioner(), NodeSetsGeneratorBase::setup(), SideSetsGeneratorBase::setup(), NEML2Action::setupDerivativeMappings(), NEML2Action::setupParameterDerivativeMappings(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SideValueSampler::SideValueSampler(), SingleRankPartitioner::SingleRankPartitioner(), SphericalGridDivision::SphericalGridDivision(), StitchBoundaryMeshGenerator::StitchBoundaryMeshGenerator(), StitchMeshGenerator::StitchMeshGenerator(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TagVectorAux::TagVectorAux(), Terminator::Terminator(), TimeDerivativeAux::TimeDerivativeAux(), Transfer::Transfer(), TransformGenerator::TransformGenerator(), TransientMultiApp::TransientMultiApp(), ParsedCurveGenerator::tSectionSpaceDefiner(), UniqueExtraIDMeshGenerator::UniqueExtraIDMeshGenerator(), TimeSequenceStepperBase::updateSequence(), UserObject::UserObject(), Checkpoint::validateExecuteOn(), ParsedAux::validateGenericVectorNames(), ParsedMaterialBase::validateVectorNames(), FunctorIC::value(), VariableCondensationPreconditioner::VariableCondensationPreconditioner(), VectorBodyForce::VectorBodyForce(), VectorFunctionDirichletBC::VectorFunctionDirichletBC(), VectorFunctionIC::VectorFunctionIC(), VolumeAux::VolumeAux(), WebServerControl::WebServerControl(), XYDelaunayGenerator::XYDelaunayGenerator(), XYMeshLineCutter::XYMeshLineCutter(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

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

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.

Referenced by MeshOnlyAction::act(), SplitMeshAction::act(), SetupDebugAction::act(), CSGOnlyAction::act(), AddActionComponentAction::act(), CommonOutputAction::act(), Action::Action(), FEProblemBase::addAnyRedistributers(), addAuxKernel(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), addAuxVariable(), DisplacedProblem::addAuxVariable(), addBoundaryCondition(), FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addConvergence(), FEProblemBase::addDamper(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), FEProblemBase::addDefaultMultiAppFixedPointConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::addDefaultSteadyStateConvergence(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDistribution(), addFESpace(), addFunction(), FEProblemBase::addFunction(), addFunctorMaterial(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVBC(), FEProblemBase::addFVInitialCondition(), FEProblemBase::addFVInterfaceKernel(), FEProblemBase::addFVKernel(), addGridFunction(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), addInitialCondition(), FEProblemBase::addInitialCondition(), DiffusionPhysicsBase::addInitialConditions(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addInterfaceMaterial(), addKernel(), FEProblemBase::addKernel(), FEProblemBase::addLinearFVBC(), FEProblemBase::addLinearFVKernel(), FEProblem::addLineSearch(), FEProblemBase::addMarker(), FEProblemBase::addMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMeshDivision(), addMFEMFESpaceFromMOOSEVariable(), addMFEMPreconditioner(), addMFEMSolver(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addOutput(), addPostprocessor(), FEProblemBase::addPostprocessor(), FEProblemBase::addPredictor(), FEProblemBase::addReporter(), FEProblemBase::addSampler(), FEProblemBase::addScalarKernel(), addSubMesh(), FEProblemBase::addTimeIntegrator(), addTransfer(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), addVariable(), DisplacedProblem::addVariable(), FEProblemBase::addVectorPostprocessor(), ADPiecewiseLinearInterpolationMaterial::ADPiecewiseLinearInterpolationMaterial(), AdvancedOutput::AdvancedOutput(), ADVectorFunctionDirichletBC::ADVectorFunctionDirichletBC(), AnnularMesh::AnnularMesh(), AnnularMeshGenerator::AnnularMeshGenerator(), Action::associateWithParameter(), AuxKernelBase::AuxKernelBase(), AuxScalarKernel::AuxScalarKernel(), BoundsBase::BoundsBase(), MooseMesh::buildTypedMesh(), PostprocessorInterface::checkParam(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), SampledOutput::cloneMesh(), LibtorchNeuralNetControl::conditionalParameterError(), Console::Console(), CommonOutputAction::create(), MultiApp::createApp(), Postprocessor::declareValue(), DumpObjectsProblem::deduceNecessaryParameters(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), 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(), 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(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MFEMCGSolver::MFEMCGSolver(), MFEMGMRESSolver::MFEMGMRESSolver(), MFEMHypreADS::MFEMHypreADS(), MFEMHypreAMS::MFEMHypreAMS(), MFEMHypreBoomerAMG::MFEMHypreBoomerAMG(), MFEMHypreFGMRES::MFEMHypreFGMRES(), MFEMHypreGMRES::MFEMHypreGMRES(), MFEMHyprePCG::MFEMHyprePCG(), MFEMOperatorJacobiSmoother::MFEMOperatorJacobiSmoother(), MFEMSuperLU::MFEMSuperLU(), MooseObject::MooseObject(), UserObjectInterface::mooseObjectError(), MooseVariableInterface< Real >::MooseVariableInterface(), MultiApp::MultiApp(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), MultiAppGeneralFieldUserObjectTransfer::MultiAppGeneralFieldUserObjectTransfer(), MultiAppTransfer::MultiAppTransfer(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NodeFaceConstraint::NodeFaceConstraint(), ConsoleUtils::outputLegacyInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MooseServer::parseDocumentForDiagnostics(), 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(), FEProblem::setInputParametersFEProblem(), FEProblemBase::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(), VectorMagnitudeFunctorMaterialTempl< is_ad >::VectorMagnitudeFunctorMaterialTempl(), and MooseApp::~MooseApp().

{ return _pars; }

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 453 of file MooseBase.h.

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

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

paramWarning() [1/2]

template<typename... Args>

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

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

Referenced by GridPartitioner::_do_partition(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), CombinerGenerator::copyIntoMesh(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), UniqueExtraIDMeshGenerator::generate(), PlaneIDMeshGenerator::generate(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

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

paramWarning() [2/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 446 of file MooseBase.h.

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

parentOutputPositionChanged()

void FEProblemBase::parentOutputPositionChanged ( )

inherited

Calls parentOutputPositionChanged() on all sub apps.

Definition at line 4685 of file FEProblemBase.C.

Referenced by TransientBase::parentOutputPositionChanged().

{
  for (const auto & it : _multi_apps)
  {
    const auto & objects = it.second.getActiveObjects();
    for (const auto & obj : objects)
      obj->parentOutputPositionChanged();
  }
}

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 78 of file PerfGraphInterface.C.

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

{
  return _pg_moose_app.perfGraph();
}

petscOptionsDatabase()

PetscOptions& FEProblemBase::petscOptionsDatabase ( )

inlineinherited

Definition at line 2347 of file FEProblemBase.h.

Referenced by Eigenvalue::prepareSolverOptions().

{ return _petsc_option_data_base; }

petscOptionsInserted()

bool& FEProblemBase::petscOptionsInserted ( )

inlineinherited

If PETSc options are already inserted.

Definition at line 2344 of file FEProblemBase.h.

Referenced by Eigenvalue::prepareSolverOptions().

{ return _is_petsc_options_inserted; }

possiblyRebuildGeomSearchPatches()

void FEProblemBase::possiblyRebuildGeomSearchPatches ( )

virtualinherited

Definition at line 8093 of file FEProblemBase.C.

Referenced by FEProblemBase::solve().

{
  if (_displaced_problem) // Only need to do this if things are moving...
  {
    TIME_SECTION("possiblyRebuildGeomSearchPatches", 5, "Rebuilding Geometric Search Patches");

    switch (_mesh.getPatchUpdateStrategy())
    {
      case Moose::Never:
        break;
      case Moose::Iteration:
        // Update the list of ghosted elements at the start of the time step
        _geometric_search_data.updateGhostedElems();
        _mesh.updateActiveSemiLocalNodeRange(_ghosted_elems);

        _displaced_problem->geomSearchData().updateGhostedElems();
        _displaced_mesh->updateActiveSemiLocalNodeRange(_ghosted_elems);

        // The commands below ensure that the sparsity of the Jacobian matrix is
        // augmented at the start of the time step using neighbor nodes from the end
        // of the previous time step.

        reinitBecauseOfGhostingOrNewGeomObjects();

        // This is needed to reinitialize PETSc output
        initPetscOutputAndSomeSolverSettings();

        break;

      case Moose::Auto:
      {
        Real max = _displaced_problem->geomSearchData().maxPatchPercentage();
        _communicator.max(max);

        // If we haven't moved very far through the patch
        if (max < 0.4)
          break;
      }
        libmesh_fallthrough();

      // Let this fall through if things do need to be updated...
      case Moose::Always:
        // Flush output here to see the message before the reinitialization, which could take a
        // while
        _console << "\n\nUpdating geometric search patches\n" << std::endl;

        _geometric_search_data.clearNearestNodeLocators();
        _mesh.updateActiveSemiLocalNodeRange(_ghosted_elems);

        _displaced_problem->geomSearchData().clearNearestNodeLocators();
        _displaced_mesh->updateActiveSemiLocalNodeRange(_ghosted_elems);

        reinitBecauseOfGhostingOrNewGeomObjects();

        // This is needed to reinitialize PETSc output
        initPetscOutputAndSomeSolverSettings();
    }
  }
}

postExecute()

void FEProblemBase::postExecute ( )

virtualinherited

Method called at the end of the simulation.

Definition at line 5702 of file FEProblemBase.C.

Referenced by MFEMSteady::execute(), SteadyBase::execute(), TransientBase::execute(), and Eigenvalue::execute().

{
  const auto & multi_apps = _multi_apps.getActiveObjects();

  for (const auto & multi_app : multi_apps)
    multi_app->postExecute();
}

predictorCleanup()

void FEProblemBase::predictorCleanup ( NumericVector< libMesh::Number > &  ghosted_solution )

virtualinherited

Perform cleanup tasks after application of predictor to solution vector.

Parameters

ghosted_solution

Ghosted solution vector

Definition at line 8006 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::setInitialSolution().

{
}

prepare() [1/2]

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

overridevirtualinherited

Implements SubProblem.

Referenced by NodalPatchRecovery::compute(), ComputeMarkerThread::onElement(), ComputeElemDampingThread::onElement(), ComputeIndicatorThread::onElement(), ComputeMaterialsObjectThread::onElement(), ComputeUserObjectsThread::onElement(), and ComputeInitialConditionThread::operator()().

prepare() [2/2]

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

overridevirtualinherited

Implements SubProblem.

prepareAssembly()

void FEProblemBase::prepareAssembly ( const THREAD_ID  tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1861 of file FEProblemBase.C.

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

{
  _assembly[tid][_current_nl_sys->number()]->prepare();
  if (_has_nonlocal_coupling)
    _assembly[tid][_current_nl_sys->number()]->prepareNonlocal();

  if (_displaced_problem && (_reinit_displaced_elem || _reinit_displaced_face))
  {
    _displaced_problem->prepareAssembly(tid);
    if (_has_nonlocal_coupling)
      _displaced_problem->prepareNonlocal(tid);
  }
}

prepareFace()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 1775 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onInterface(), and ComputeUserObjectsThread::onInternalSide().

{
  for (auto & nl : _nl)
    nl->prepareFace(tid, true);
  _aux->prepareFace(tid, false);

  if (_displaced_problem && (_reinit_displaced_elem || _reinit_displaced_face))
    _displaced_problem->prepareFace(_displaced_mesh->elemPtr(elem->id()), tid);
}

prepareFaceShapes()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2120 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onBoundary().

{
  _assembly[tid][_current_nl_sys->number()]->copyFaceShapes(var);
}

prepareKokkosMaterials()

void FEProblemBase::prepareKokkosMaterials ( const std::unordered_set< unsigned int > &  consumer_needed_mat_props )

inherited

prepareMaterials()

void FEProblemBase::prepareMaterials ( const std::unordered_set< unsigned int > &  consumer_needed_mat_props, const SubdomainID  blk_id, const THREAD_ID  tid  )

inherited

Add the MooseVariables and the material properties that the current materials depend on to the dependency list.

Parameters

consumer_needed_mat_props	The material properties needed by consumer objects (other than the materials themselves)
blk_id	The subdomain ID for which we are preparing our list of needed vars and props
tid	The thread ID we are preparing the requirements for

This MUST be done after the moose variable dependency list has been set for all the other objects using the setActiveElementalMooseVariables API!

Definition at line 4128 of file FEProblemBase.C.

Referenced by ComputeMarkerThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), NonlinearThread::subdomainChanged(), and ComputeUserObjectsThread::subdomainChanged().

{
  std::set<MooseVariableFEBase *> needed_moose_vars;
  std::unordered_set<unsigned int> needed_mat_props;

  if (_all_materials.hasActiveBlockObjects(blk_id, tid))
  {
    _all_materials.updateVariableDependency(needed_moose_vars, tid);
    _all_materials.updateBlockMatPropDependency(blk_id, needed_mat_props, tid);
  }

  const auto & ids = _mesh.getSubdomainBoundaryIds(blk_id);
  for (const auto id : ids)
  {
    _materials.updateBoundaryVariableDependency(id, needed_moose_vars, tid);
    _materials.updateBoundaryMatPropDependency(id, needed_mat_props, tid);
  }

  const auto & current_active_elemental_moose_variables = getActiveElementalMooseVariables(tid);
  needed_moose_vars.insert(current_active_elemental_moose_variables.begin(),
                           current_active_elemental_moose_variables.end());

  needed_mat_props.insert(consumer_needed_mat_props.begin(), consumer_needed_mat_props.end());

  setActiveElementalMooseVariables(needed_moose_vars, tid);
  setActiveMaterialProperties(needed_mat_props, tid);
}

prepareNeighborShapes()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2126 of file FEProblemBase.C.

{
  _assembly[tid][_current_nl_sys->number()]->copyNeighborShapes(var);
}

preparePRefinement()

void SubProblem::preparePRefinement ( )

inherited

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

Definition at line 1337 of file SubProblem.C.

Referenced by FEProblemBase::init().

{
  std::unordered_set<FEFamily> disable_families;
  for (const auto & [family, flag] : _family_for_p_refinement)
    if (flag)
      disable_families.insert(family);

  for (const auto tid : make_range(libMesh::n_threads()))
    for (const auto s : make_range(numNonlinearSystems()))
      assembly(tid, s).havePRefinement(disable_families);

  auto & eq = es();
  for (const auto family : disable_families)
    for (const auto i : make_range(eq.n_systems()))
    {
      auto & system = eq.get_system(i);
      auto & dof_map = system.get_dof_map();
      for (const auto vg : make_range(system.n_variable_groups()))
      {
        const auto & var_group = system.variable_group(vg);
        if (var_group.type().family == family)
          dof_map.should_p_refine(vg, false);
      }
    }

  _have_p_refinement = true;
}

prepareShapes()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2114 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onElement().

{
  _assembly[tid][_current_nl_sys->number()]->copyShapes(var);
}

preserveMatrixSparsityPattern()

bool FEProblemBase::preserveMatrixSparsityPattern ( ) const

inlineinherited

Will return True if the executioner in use requires preserving the sparsity pattern of the matrices being formed during the solve.

This is usually the Jacobian.

Definition at line 2165 of file FEProblemBase.h.

{ return _preserve_matrix_sparsity_pattern; };

projectFunctionOnCustomRange()

void FEProblemBase::projectFunctionOnCustomRange ( ConstElemRange &  elem_range, Number(*)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &)  func, Gradient(*)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &)  func_grad, const libMesh::Parameters &  params, const VariableName &  target_var  )

inherited

Project a function onto a range of elements for a given variable.

Warning

The current implementation is not ideal. The projection takes place on all local active elements, ignoring the specified elem_range. After the projection, dof values on the specified elem_range are copied over to the current solution vector. This should be fixed once the project_vector or project_solution API is modified to take a custom element range.

Parameters

elem_range	Element range to project on
func	Function to project
func_grad	Gradient of the function
params	Parameters to pass to the function
target_var	variable name to project

Definition at line 3828 of file FEProblemBase.C.

Referenced by ElementSubdomainModifierBase::extrapolatePolynomial().

{
  mooseAssert(!Threads::in_threads,
              "We're performing a projection based on data from just the thread 0 variable, so any "
              "modifications to the variable solution must have been thread joined already");

  const auto & var = getStandardVariable(0, target_var);
  const auto var_num = var.number();
  const auto sn = systemNumForVariable(target_var);
  auto & sys = getSystemBase(sn);

  // Let libmesh handle the projection
  System & libmesh_sys = getSystem(target_var);
  auto temp_vec = libmesh_sys.current_local_solution->zero_clone();
  libmesh_sys.project_vector(func, func_grad, params, *temp_vec);
  temp_vec->close();

  // Get the dof indices to copy
  DofMap & dof_map = sys.dofMap();
  std::set<dof_id_type> dof_indices;
  std::vector<dof_id_type> elem_dof_indices;

  for (const auto & elem : elem_range)
  {
    dof_map.dof_indices(elem, elem_dof_indices, var_num);
    dof_indices.insert(elem_dof_indices.begin(), elem_dof_indices.end());
  }
  std::vector<dof_id_type> dof_indices_v(dof_indices.begin(), dof_indices.end());

  // Copy the projected values into the solution vector
  std::vector<Real> dof_vals;
  temp_vec->get(dof_indices_v, dof_vals);
  mooseAssert(sys.solution().closed(),
              "The solution should be closed before mapping our projection");
  sys.solution().insert(dof_vals, dof_indices_v);
  sys.solution().close();
  sys.solution().localize(*libmesh_sys.current_local_solution, sys.dofMap().get_send_list());
}

projectInitialConditionOnCustomRange()

void FEProblemBase::projectInitialConditionOnCustomRange ( libMesh::ConstElemRange &  elem_range, ConstBndNodeRange &  bnd_node_range, const std::optional< std::set< VariableName >> &  target_vars = std::nullopt  )

inherited

Project initial conditions for custom elem_range and bnd_node_range This is needed when elements/boundary nodes are added to a specific subdomain at an intermediate step.

Parameters

elem_range	Element range to project on
bnd_node_range	Boundary node range to project on
target_vars	Set of variable names to project ICs

Definition at line 3753 of file FEProblemBase.C.

Referenced by ElementSubdomainModifierBase::applyIC(), and ActivateElementsUserObjectBase::initSolutions().

{
  if (target_vars)
  {
    ComputeInitialConditionThread cic(*this, &(*target_vars));
    Threads::parallel_reduce(elem_range, cic);
  }
  else
  {
    ComputeInitialConditionThread cic(*this);
    Threads::parallel_reduce(elem_range, cic);
  }

  // Need to close the solution vector here so that boundary ICs take precendence
  for (auto & nl : _nl)
    nl->solution().close();
  _aux->solution().close();

  if (target_vars)
  {
    ComputeBoundaryInitialConditionThread cbic(*this, &(*target_vars));
    Threads::parallel_reduce(bnd_nodes, cbic);
  }
  else
  {
    ComputeBoundaryInitialConditionThread cbic(*this);
    Threads::parallel_reduce(bnd_nodes, cbic);
  }

  for (auto & nl : _nl)
    nl->solution().close();
  _aux->solution().close();

  // Also, load values into the SCALAR dofs
  // Note: We assume that all SCALAR dofs are on the
  // processor with highest ID
  if (processor_id() == (n_processors() - 1) && _scalar_ics.hasActiveObjects())
  {
    const auto & ics = _scalar_ics.getActiveObjects();
    for (const auto & ic : ics)
    {
      MooseVariableScalar & var = ic->variable();

      if (target_vars && !target_vars->count(var.name()))
        continue;

      var.reinit();

      DenseVector<Number> vals(var.order());
      ic->compute(vals);

      const unsigned int n_scalar_dofs = var.dofIndices().size();
      for (unsigned int i = 0; i < n_scalar_dofs; i++)
      {
        const auto global_index = var.dofIndices()[i];
        var.sys().solution().set(global_index, vals(i));
        var.setValue(i, vals(i));
      }
    }
  }

  for (auto & nl : _nl)
  {
    nl->solution().close();
    nl->solution().localize(*nl->system().current_local_solution, nl->dofMap().get_send_list());
  }

  _aux->solution().close();
  _aux->solution().localize(*_aux->sys().current_local_solution, _aux->dofMap().get_send_list());
}

projectSolution()

void FEProblemBase::projectSolution ( )

inherited

Definition at line 3685 of file FEProblemBase.C.

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

{
  TIME_SECTION("projectSolution", 2, "Projecting Initial Solutions")

  FloatingPointExceptionGuard fpe_guard(_app);

  ConstElemRange & elem_range = *_mesh.getActiveLocalElementRange();
  ComputeInitialConditionThread cic(*this);
  Threads::parallel_reduce(elem_range, cic);

  if (haveFV())
  {
    using ElemInfoRange = StoredRange<MooseMesh::const_elem_info_iterator, const ElemInfo *>;
    ElemInfoRange elem_info_range(_mesh.ownedElemInfoBegin(), _mesh.ownedElemInfoEnd());

    ComputeFVInitialConditionThread cfvic(*this);
    Threads::parallel_reduce(elem_info_range, cfvic);
  }

  // Need to close the solution vector here so that boundary ICs take precendence
  for (auto & nl : _nl)
    nl->solution().close();
  _aux->solution().close();

  // now run boundary-restricted initial conditions
  ConstBndNodeRange & bnd_nodes = *_mesh.getBoundaryNodeRange();
  ComputeBoundaryInitialConditionThread cbic(*this);
  Threads::parallel_reduce(bnd_nodes, cbic);

  for (auto & nl : _nl)
    nl->solution().close();
  _aux->solution().close();

  // Also, load values into the SCALAR dofs
  // Note: We assume that all SCALAR dofs are on the
  // processor with highest ID
  if (processor_id() == (n_processors() - 1) && _scalar_ics.hasActiveObjects())
  {
    const auto & ics = _scalar_ics.getActiveObjects();
    for (const auto & ic : ics)
    {
      MooseVariableScalar & var = ic->variable();
      var.reinit();

      DenseVector<Number> vals(var.order());
      ic->compute(vals);

      const unsigned int n_scalar_dofs = var.dofIndices().size();
      for (unsigned int i = 0; i < n_scalar_dofs; i++)
      {
        const auto global_index = var.dofIndices()[i];
        var.sys().solution().set(global_index, vals(i));
        var.setValue(i, vals(i));
      }
    }
  }

  for (auto & sys : _solver_systems)
  {
    sys->solution().close();
    sys->solution().localize(*sys->system().current_local_solution, sys->dofMap().get_send_list());
  }

  _aux->solution().close();
  _aux->solution().localize(*_aux->sys().current_local_solution, _aux->dofMap().get_send_list());
}

queryParam()

template<typename T >

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

inherited

Query a parameter for the object.

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 395 of file MooseBase.h.

{
  return isParamValid(name) ? &getParam<T>(name) : nullptr;
}

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

registerRandomInterface()

void FEProblemBase::registerRandomInterface ( RandomInterface &  random_interface, const std::string &  name  )

inherited

Definition at line 8923 of file FEProblemBase.C.

Referenced by RandomInterface::setRandomResetFrequency().

{
  auto insert_pair = moose_try_emplace(
      _random_data_objects, name, std::make_unique<RandomData>(*this, random_interface));

  auto random_data_ptr = insert_pair.first->second.get();
  random_interface.setRandomDataPointer(random_data_ptr);
}

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 53 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 64 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  )

inherited

Register an unfulfilled functor request.

reinitBecauseOfGhostingOrNewGeomObjects()

void FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects ( bool  mortar_changed = false )

protectedinherited

Call when it is possible that the needs for ghosted elements has changed.

Parameters

mortar_changed

Whether an update of mortar data has been requested since the last EquationSystems (re)initialization

Definition at line 5338 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup(), FEProblemBase::meshChanged(), and FEProblemBase::possiblyRebuildGeomSearchPatches().

{
  TIME_SECTION("reinitBecauseOfGhostingOrNewGeomObjects",
               3,
               "Reinitializing Because of Geometric Search Objects");

  // Need to see if _any_ processor has ghosted elems or geometry objects.
  bool needs_reinit = !_ghosted_elems.empty();
  needs_reinit = needs_reinit || !_geometric_search_data._nearest_node_locators.empty() ||
                 (_mortar_data->hasObjects() && mortar_changed);
  needs_reinit =
      needs_reinit || (_displaced_problem &&
                       (!_displaced_problem->geomSearchData()._nearest_node_locators.empty() ||
                        (_mortar_data->hasDisplacedObjects() && mortar_changed)));
  _communicator.max(needs_reinit);

  if (needs_reinit)
  {
    // Call reinit to get the ghosted vectors correct now that some geometric search has been done
    es().reinit();

    if (_displaced_mesh)
      _displaced_problem->es().reinit();
  }
}

reinitDirac()

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

overridevirtualinherited

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

The maximum number of qps can rise if several Dirac points are added to a single element. In that case we need to resize the zeros to compensate.

Implements SubProblem.

Definition at line 2165 of file FEProblemBase.C.

Referenced by ComputeDiracThread::onElement().

{
  std::vector<Point> & points = _dirac_kernel_info.getPoints()[elem].first;

  unsigned int n_points = points.size();

  if (n_points)
  {
    if (n_points > _max_qps)
    {
      _max_qps = n_points;

      unsigned int max_qpts = getMaxQps();
      for (unsigned int tid = 0; tid < libMesh::n_threads(); ++tid)
      {
        // the highest available order in libMesh is 43
        _scalar_zero[tid].resize(FORTYTHIRD, 0);
        _zero[tid].resize(max_qpts, 0);
        _grad_zero[tid].resize(max_qpts, RealGradient(0.));
        _second_zero[tid].resize(max_qpts, RealTensor(0.));
        _vector_zero[tid].resize(max_qpts, RealGradient(0.));
        _vector_curl_zero[tid].resize(max_qpts, RealGradient(0.));
      }
    }

    for (const auto i : index_range(_nl))
    {
      _assembly[tid][i]->reinitAtPhysical(elem, points);
      _nl[i]->prepare(tid);
    }
    _aux->prepare(tid);

    reinitElem(elem, tid);
  }

  _assembly[tid][_current_nl_sys->number()]->prepare();
  if (_has_nonlocal_coupling)
    _assembly[tid][_current_nl_sys->number()]->prepareNonlocal();

  bool have_points = n_points > 0;
  if (_displaced_problem && (_reinit_displaced_elem))
  {
    have_points |= _displaced_problem->reinitDirac(_displaced_mesh->elemPtr(elem->id()), tid);
    if (_has_nonlocal_coupling)
      _displaced_problem->prepareNonlocal(tid);
  }

  return have_points;
}

reinitElem()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2220 of file FEProblemBase.C.

Referenced by NodalPatchRecovery::compute(), ComputeMarkerThread::onElement(), ComputeElemDampingThread::onElement(), ComputeIndicatorThread::onElement(), ComputeMaterialsObjectThread::onElement(), ComputeUserObjectsThread::onElement(), ComputeInitialConditionThread::operator()(), FEProblemBase::reinitDirac(), and FEProblemBase::reinitElemPhys().

{
  for (auto & sys : _solver_systems)
    sys->reinitElem(elem, tid);
  _aux->reinitElem(elem, tid);

  if (_displaced_problem && _reinit_displaced_elem)
    _displaced_problem->reinitElem(_displaced_mesh->elemPtr(elem->id()), tid);
}

reinitElemFace() [1/2]

void FEProblemBase::reinitElemFace ( const Elem *  elem, unsigned int  side, BoundaryID  , const THREAD_ID  tid  )

inherited

Referenced by ComputeMaterialsObjectThread::onBoundary(), ComputeUserObjectsThread::onBoundary(), ComputeMaterialsObjectThread::onInterface(), and NonlinearThread::prepareFace().

reinitElemFace() [2/2]

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

overridevirtualinherited

Implements SubProblem.

reinitElemFaceRef()

void FEProblemBase::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  )

overridevirtualinherited

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 from SubProblem.

Definition at line 9270 of file FEProblemBase.C.

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

{
  SubProblem::reinitElemFaceRef(elem, side, tolerance, pts, weights, tid);

  if (_displaced_problem)
    _displaced_problem->reinitElemFaceRef(
        _displaced_mesh->elemPtr(elem->id()), side, tolerance, pts, weights, tid);
}

reinitElemNeighborAndLowerD()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2406 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::onInternalSide(), and NonlinearThread::onInternalSide().

{
  reinitNeighbor(elem, side, tid);

  const Elem * lower_d_elem = _mesh.getLowerDElem(elem, side);
  if (lower_d_elem && _mesh.interiorLowerDBlocks().count(lower_d_elem->subdomain_id()) > 0)
    reinitLowerDElem(lower_d_elem, tid);
  else
  {
    // with mesh refinement, lower-dimensional element might be defined on neighbor side
    auto & neighbor = _assembly[tid][0]->neighbor();
    auto & neighbor_side = _assembly[tid][0]->neighborSide();
    const Elem * lower_d_elem_neighbor = _mesh.getLowerDElem(neighbor, neighbor_side);
    if (lower_d_elem_neighbor &&
        _mesh.interiorLowerDBlocks().count(lower_d_elem_neighbor->subdomain_id()) > 0)
    {
      auto qps = _assembly[tid][0]->qPointsFaceNeighbor().stdVector();
      std::vector<Point> reference_points;
      FEMap::inverse_map(
          lower_d_elem_neighbor->dim(), lower_d_elem_neighbor, qps, reference_points);
      reinitLowerDElem(lower_d_elem_neighbor, tid, &reference_points);
    }
  }

  if (_displaced_problem && (_reinit_displaced_face || _reinit_displaced_neighbor))
    _displaced_problem->reinitElemNeighborAndLowerD(
        _displaced_mesh->elemPtr(elem->id()), side, tid);
}

reinitElemPhys()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2231 of file FEProblemBase.C.

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute().

{
  mooseAssert(_mesh.queryElemPtr(elem->id()) == elem,
              "Are you calling this method with a displaced mesh element?");

  for (const auto i : index_range(_solver_systems))
  {
    _assembly[tid][i]->reinitAtPhysical(elem, phys_points_in_elem);
    _solver_systems[i]->prepare(tid);
    _assembly[tid][i]->prepare();
    if (_has_nonlocal_coupling)
      _assembly[tid][i]->prepareNonlocal();
  }
  _aux->prepare(tid);

  reinitElem(elem, tid);
}

reinitFVFace()

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

inherited

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

reinitKokkosMaterials()

void FEProblemBase::reinitKokkosMaterials ( )

inherited

reinitLowerDElem()

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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2279 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onBoundary(), NonlinearThread::prepareFace(), and FEProblemBase::reinitElemNeighborAndLowerD().

{
  SubProblem::reinitLowerDElem(lower_d_elem, tid, pts, weights);

  if (_displaced_problem && _displaced_mesh)
    _displaced_problem->reinitLowerDElem(
        _displaced_mesh->elemPtr(lower_d_elem->id()), tid, pts, weights);
}

reinitMaterials()

void FEProblemBase::reinitMaterials ( SubdomainID  blk_id, const THREAD_ID  tid, bool  swap_stateful = true  )

inherited

Definition at line 4159 of file FEProblemBase.C.

Referenced by NodalPatchRecovery::compute(), ComputeMarkerThread::onElement(), ComputeIndicatorThread::onElement(), ComputeDiracThread::onElement(), and ComputeUserObjectsThread::onElement().

{
  if (hasActiveMaterialProperties(tid))
  {
    auto && elem = _assembly[tid][0]->elem();
    unsigned int n_points = _assembly[tid][0]->qRule()->n_points();

    auto & material_data = _material_props.getMaterialData(tid);
    material_data.resize(n_points);

    // Only swap if requested
    if (swap_stateful)
      material_data.swap(*elem);

    if (_discrete_materials.hasActiveBlockObjects(blk_id, tid))
      material_data.reset(_discrete_materials.getActiveBlockObjects(blk_id, tid));

    if (_materials.hasActiveBlockObjects(blk_id, tid))
      material_data.reinit(_materials.getActiveBlockObjects(blk_id, tid));
  }
}

reinitMaterialsBoundary()

void FEProblemBase::reinitMaterialsBoundary ( BoundaryID  boundary_id, const THREAD_ID  tid, bool  swap_stateful = true, const std::deque< MaterialBase *> *  reinit_mats = nullptr  )

inherited

reinit materials on a boundary

Parameters

boundary_id	The boundary on which to reinit corresponding materials
tid	The thread id
swap_stateful	Whether to swap stateful material properties between MaterialData and MaterialPropertyStorage
execute_stateful	Whether to execute material objects that have stateful properties. This should be false when for example executing material objects for mortar contexts in which stateful properties don't make sense
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4304 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments(), ComputeUserObjectsThread::onBoundary(), NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), and NonlinearThread::prepareFace().

{
  if (hasActiveMaterialProperties(tid) && needBoundaryMaterialOnSide(boundary_id, tid))
  {
    auto && elem = _assembly[tid][0]->elem();
    unsigned int side = _assembly[tid][0]->side();
    unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();

    auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
    bnd_material_data.resize(n_points);

    if (swap_stateful && !bnd_material_data.isSwapped())
      bnd_material_data.swap(*elem, side);

    if (_discrete_materials.hasActiveBoundaryObjects(boundary_id, tid))
      bnd_material_data.reset(_discrete_materials.getActiveBoundaryObjects(boundary_id, tid));

    if (reinit_mats)
      bnd_material_data.reinit(*reinit_mats);
    else if (_materials.hasActiveBoundaryObjects(boundary_id, tid))
      bnd_material_data.reinit(_materials.getActiveBoundaryObjects(boundary_id, tid));
  }
}

reinitMaterialsFace()

void FEProblemBase::reinitMaterialsFace ( SubdomainID  blk_id, const THREAD_ID  tid, bool  swap_stateful = true, const std::deque< MaterialBase *> *  reinit_mats = nullptr  )

inherited

reinit materials on element faces

Parameters

blk_id	The subdomain on which the element owning the face lives
tid	The thread id
swap_stateful	Whether to swap stateful material properties between MaterialData and MaterialPropertyStorage
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4182 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments(), ComputeIndicatorThread::onInternalSide(), NonlinearThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and NonlinearThread::prepareFace().

{
  // we reinit more often than needed here because we dont have a way to check whether
  // we need to compute the face materials on a particular (possibly external) face
  if (hasActiveMaterialProperties(tid))
  {
    auto && elem = _assembly[tid][0]->elem();
    unsigned int side = _assembly[tid][0]->side();
    unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();

    auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
    bnd_material_data.resize(n_points);

    if (swap_stateful && !bnd_material_data.isSwapped())
      bnd_material_data.swap(*elem, side);

    if (_discrete_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
      bnd_material_data.reset(
          _discrete_materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));

    if (reinit_mats)
      bnd_material_data.reinit(*reinit_mats);
    else if (_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
      bnd_material_data.reinit(
          _materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
  }
}

reinitMaterialsFaceOnBoundary()

void FEProblemBase::reinitMaterialsFaceOnBoundary ( const BoundaryID  boundary_id, const SubdomainID  blk_id, const THREAD_ID  tid, const bool  swap_stateful = true, const std::deque< MaterialBase *> *const  reinit_mats = nullptr  )

inherited

reinit materials on element faces on a boundary (internal or external) This specific routine helps us not reinit when don't need to

Parameters

boundary_id	The boundary on which the face belongs
blk_id	The block id to which the element (who owns the face) belong
tid	The thread id
swap_stateful	Whether to swap stateful material properties between MaterialData and MaterialPropertyStorage
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4214 of file FEProblemBase.C.

Referenced by ComputeUserObjectsThread::onBoundary(), NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), and NonlinearThread::prepareFace().

{
  if (hasActiveMaterialProperties(tid) && (needBoundaryMaterialOnSide(boundary_id, tid) ||
                                           needInterfaceMaterialOnSide(boundary_id, tid) ||
                                           needInternalNeighborSideMaterial(blk_id, tid)))
  {
    const auto * const elem = _assembly[tid][0]->elem();
    unsigned int side = _assembly[tid][0]->side();
    unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();

    auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
    bnd_material_data.resize(n_points);

    if (swap_stateful && !bnd_material_data.isSwapped())
      bnd_material_data.swap(*elem, side);

    if (_discrete_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
      bnd_material_data.reset(
          _discrete_materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));

    if (reinit_mats)
      bnd_material_data.reinit(*reinit_mats);
    else if (_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
      bnd_material_data.reinit(
          _materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
  }
}

reinitMaterialsInterface()

void FEProblemBase::reinitMaterialsInterface ( BoundaryID  boundary_id, const THREAD_ID  tid, bool  swap_stateful = true  )

inherited

Definition at line 4332 of file FEProblemBase.C.

Referenced by NonlinearThread::onInterface(), and ComputeUserObjectsThread::onInterface().

{
  if (hasActiveMaterialProperties(tid) && needInterfaceMaterialOnSide(boundary_id, tid))
  {
    const Elem * const & elem = _assembly[tid][0]->elem();
    unsigned int side = _assembly[tid][0]->side();
    unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();

    auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
    bnd_material_data.resize(n_points);

    if (swap_stateful && !bnd_material_data.isSwapped())
      bnd_material_data.swap(*elem, side);

    if (_interface_materials.hasActiveBoundaryObjects(boundary_id, tid))
      bnd_material_data.reinit(_interface_materials.getActiveBoundaryObjects(boundary_id, tid));
  }
}

reinitMaterialsNeighbor()

void FEProblemBase::reinitMaterialsNeighbor ( SubdomainID  blk_id, const THREAD_ID  tid, bool  swap_stateful = true, const std::deque< MaterialBase *> *  reinit_mats = nullptr  )

inherited

reinit materials on the neighboring element face

Parameters

blk_id	The subdomain on which the neighbor element lives
tid	The thread id
swap_stateful	Whether to swap stateful material properties between MaterialData and MaterialPropertyStorage
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4264 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), NonlinearThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), FEProblemBase::reinitMaterialsNeighborOnBoundary(), and NonlinearSystemBase::reinitNodeFace().

{
  if (hasActiveMaterialProperties(tid))
  {
    // NOTE: this will not work with h-adaptivity
    // lindsayad: why not?

    const Elem * neighbor = _assembly[tid][0]->neighbor();
    unsigned int neighbor_side = neighbor->which_neighbor_am_i(_assembly[tid][0]->elem());

    mooseAssert(neighbor, "neighbor should be non-null");
    mooseAssert(blk_id == neighbor->subdomain_id(),
                "The provided blk_id " << blk_id << " and neighbor subdomain ID "
                                       << neighbor->subdomain_id() << " do not match.");

    unsigned int n_points = _assembly[tid][0]->qRuleNeighbor()->n_points();

    auto & neighbor_material_data = _neighbor_material_props.getMaterialData(tid);
    neighbor_material_data.resize(n_points);

    // Only swap if requested
    if (swap_stateful)
      neighbor_material_data.swap(*neighbor, neighbor_side);

    if (_discrete_materials[Moose::NEIGHBOR_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
      neighbor_material_data.reset(
          _discrete_materials[Moose::NEIGHBOR_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));

    if (reinit_mats)
      neighbor_material_data.reinit(*reinit_mats);
    else if (_materials[Moose::NEIGHBOR_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
      neighbor_material_data.reinit(
          _materials[Moose::NEIGHBOR_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
  }
}

reinitMaterialsNeighborOnBoundary()

void FEProblemBase::reinitMaterialsNeighborOnBoundary ( const BoundaryID  boundary_id, const SubdomainID  blk_id, const THREAD_ID  tid, const bool  swap_stateful = true, const std::deque< MaterialBase *> *const  reinit_mats = nullptr  )

inherited

reinit materials on neighbor element (usually faces) on a boundary (internal or external) This specific routine helps us not reinit when don't need to

Parameters

boundary_id	The boundary on which the face belongs
blk_id	The block id to which the element (who owns the face) belong
tid	The thread id
swap_stateful	Whether to swap stateful material properties between MaterialData and MaterialPropertyStorage
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4247 of file FEProblemBase.C.

Referenced by NonlinearThread::onInterface().

{
  // Since objects don't declare whether they need the face or neighbor (side) material properties,
  // we use the same criteria for skipping material property computations as for face material
  // properties This could be a future optimization.
  if (hasActiveMaterialProperties(tid) && (needBoundaryMaterialOnSide(boundary_id, tid) ||
                                           needInterfaceMaterialOnSide(boundary_id, tid) ||
                                           needInternalNeighborSideMaterial(blk_id, tid)))
    reinitMaterialsNeighbor(blk_id, tid, swap_stateful, reinit_mats);
}

reinitMortarElem()

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

inherited

Reinit a mortar element to obtain a valid JxW.

Definition at line 995 of file SubProblem.C.

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

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

reinitMortarUserObjects()

void FEProblemBase::reinitMortarUserObjects ( BoundaryID  primary_boundary_id, BoundaryID  secondary_boundary_id, bool  displaced  )

inherited

Call reinit on mortar user objects with matching primary boundary ID, secondary boundary ID, and displacement characteristics.

Definition at line 9535 of file FEProblemBase.C.

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

{
  const auto mortar_uos =
      getMortarUserObjects(primary_boundary_id, secondary_boundary_id, displaced);
  for (auto * const mortar_uo : mortar_uos)
  {
    mortar_uo->setNormals();
    mortar_uo->reinit();
  }
}

reinitNeighbor()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2367 of file FEProblemBase.C.

Referenced by ComputeMaterialsObjectThread::onInterface(), NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and FEProblemBase::reinitElemNeighborAndLowerD().

{
  setNeighborSubdomainID(elem, side, tid);

  const Elem * neighbor = elem->neighbor_ptr(side);
  unsigned int neighbor_side = neighbor->which_neighbor_am_i(elem);

  for (const auto i : index_range(_nl))
  {
    _assembly[tid][i]->reinitElemAndNeighbor(elem, side, neighbor, neighbor_side);
    _nl[i]->prepareNeighbor(tid);
    // Called during stateful material property evaluation outside of solve
    _assembly[tid][i]->prepareNeighbor();
  }
  _aux->prepareNeighbor(tid);

  for (auto & nl : _nl)
  {
    nl->reinitElemFace(elem, side, tid);
    nl->reinitNeighborFace(neighbor, neighbor_side, tid);
  }
  _aux->reinitElemFace(elem, side, tid);
  _aux->reinitNeighborFace(neighbor, neighbor_side, tid);

  if (_displaced_problem && _reinit_displaced_neighbor)
  {
    // There are cases like for cohesive zone modeling without significant sliding where we cannot
    // use FEInterface::inverse_map in Assembly::reinitElemAndNeighbor in the displaced problem
    // because the physical points coming from the element don't actually lie on the neighbor.
    // Moreover, what's the point of doing another physical point inversion in other cases? We only
    // care about the reference points which we can just take from the undisplaced computation
    const auto & displaced_ref_pts = _assembly[tid][0]->qRuleNeighbor()->get_points();

    _displaced_problem->reinitNeighbor(
        _displaced_mesh->elemPtr(elem->id()), side, tid, &displaced_ref_pts);
  }
}

reinitNeighborFaceRef()

void FEProblemBase::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  )

overridevirtualinherited

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 from SubProblem.

Definition at line 9285 of file FEProblemBase.C.

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

{
  SubProblem::reinitNeighborFaceRef(neighbor_elem, neighbor_side, tolerance, pts, weights, tid);

  if (_displaced_problem)
    _displaced_problem->reinitNeighborFaceRef(
        _displaced_mesh->elemPtr(neighbor_elem->id()), neighbor_side, tolerance, pts, weights, tid);
}

reinitNeighborLowerDElem()

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

inherited

reinitialize a neighboring lower dimensional element

Definition at line 988 of file SubProblem.C.

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

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

reinitNeighborPhys() [1/2]

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

overridevirtualinherited

Implements SubProblem.

Referenced by NonlinearSystemBase::reinitNodeFace().

reinitNeighborPhys() [2/2]

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

overridevirtualinherited

Implements SubProblem.

reinitNode()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2292 of file FEProblemBase.C.

Referenced by NodalPatchRecovery::compute(), NonlinearSystemBase::computeResidualInternal(), ComputeNodalUserObjectsThread::onNode(), ComputeNodalDampingThread::onNode(), ComputeNodalKernelsThread::onNode(), and ComputeNodalKernelJacobiansThread::onNode().

{
  if (_displaced_problem && _reinit_displaced_elem)
    _displaced_problem->reinitNode(&_displaced_mesh->nodeRef(node->id()), tid);

  for (const auto i : index_range(_nl))
  {
    _assembly[tid][i]->reinit(node);
    _nl[i]->reinitNode(node, tid);
  }
  _aux->reinitNode(node, tid);
}

reinitNodeFace()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2306 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCs(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), ComputeNodalKernelBcsThread::onNode(), ComputeNodalKernelBCJacobiansThread::onNode(), NonlinearSystemBase::reinitNodeFace(), NonlinearSystemBase::setConstraintSecondaryValues(), and NonlinearSystemBase::setInitialSolution().

{
  if (_displaced_problem && _reinit_displaced_face)
    _displaced_problem->reinitNodeFace(&_displaced_mesh->nodeRef(node->id()), bnd_id, tid);

  for (const auto i : index_range(_nl))
  {
    _assembly[tid][i]->reinit(node);
    _nl[i]->reinitNodeFace(node, bnd_id, tid);
  }
  _aux->reinitNodeFace(node, bnd_id, tid);
}

reinitNodes()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2320 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::enforceNodalConstraintsJacobian(), and NonlinearSystemBase::enforceNodalConstraintsResidual().

{
  if (_displaced_problem && _reinit_displaced_elem)
    _displaced_problem->reinitNodes(nodes, tid);

  for (auto & nl : _nl)
    nl->reinitNodes(nodes, tid);
  _aux->reinitNodes(nodes, tid);
}

reinitNodesNeighbor()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2331 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::enforceNodalConstraintsJacobian(), and NonlinearSystemBase::enforceNodalConstraintsResidual().

{
  if (_displaced_problem && _reinit_displaced_elem)
    _displaced_problem->reinitNodesNeighbor(nodes, tid);

  for (auto & nl : _nl)
    nl->reinitNodesNeighbor(nodes, tid);
  _aux->reinitNodesNeighbor(nodes, tid);
}

reinitOffDiagScalars()

void FEProblemBase::reinitOffDiagScalars ( const THREAD_ID  tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 2359 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians(), NonlinearSystemBase::constraintJacobians(), and NonlinearThread::onElement().

{
  _assembly[tid][_current_nl_sys->number()]->prepareOffDiagScalar();
  if (_displaced_problem)
    _displaced_problem->reinitOffDiagScalars(tid);
}

reinitScalars()

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

overridevirtualinherited

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

Implements SubProblem.

Definition at line 2342 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeResidualTags(), NonlinearSystemBase::computeScalarKernelsJacobians(), AuxiliarySystem::computeScalarVars(), and FEProblemBase::initialSetup().

{
  TIME_SECTION("reinitScalars", 3, "Reinitializing Scalar Variables");

  if (_displaced_problem && _reinit_displaced_elem)
    _displaced_problem->reinitScalars(tid, reinit_for_derivative_reordering);

  for (auto & nl : _nl)
    nl->reinitScalars(tid, reinit_for_derivative_reordering);
  _aux->reinitScalars(tid, reinit_for_derivative_reordering);

  // This is called outside of residual/Jacobian call-backs
  for (auto & assembly : _assembly[tid])
    assembly->prepareScalar();
}

removeAlgebraicGhostingFunctor()

void SubProblem::removeAlgebraicGhostingFunctor ( libMesh::GhostingFunctor &  algebraic_gf )

inherited

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

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

inherited

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

Definition at line 1111 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);
}

reportMooseObjectDependency()

void FEProblemBase::reportMooseObjectDependency ( MooseObject *  a, MooseObject *  b  )

inherited

Register a MOOSE object dependency so we can either order operations properly or report when we cannot.

a -> b (a depends on b)

Definition at line 5332 of file FEProblemBase.C.

{
  //<< "Object " << a->name() << " -> " << b->name() << std::endl;
}

resetFailNextNonlinearConvergenceCheck()

void FEProblemBase::resetFailNextNonlinearConvergenceCheck ( )

inlineinherited

Tell the problem that the nonlinear convergence check(s) may proceed as normal.

Definition at line 2621 of file FEProblemBase.h.

Referenced by Moose::PetscSupport::petscNonlinearConverged().

{ resetFailNextSystemConvergenceCheck(); }

resetFailNextSystemConvergenceCheck()

void FEProblemBase::resetFailNextSystemConvergenceCheck ( )

inlineinherited

Tell the problem that the system convergence check(s) may proceed as normal.

Definition at line 2623 of file FEProblemBase.h.

Referenced by Moose::PetscSupport::petscLinearConverged(), and FEProblemBase::resetFailNextNonlinearConvergenceCheck().

{ _fail_next_system_convergence_check = false; }

residualSetup()

void FEProblemBase::residualSetup ( )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 9435 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::residualSetup().

{
  SubProblem::residualSetup();
  // We need to setup all the nonlinear systems other than our current one which actually called
  // this method (so we have to make sure we don't go in a circle)
  for (const auto i : make_range(numNonlinearSystems()))
    if (i != currentNlSysNum())
      _nl[i]->residualSetup();
  // We don't setup the aux sys because that's been done elsewhere
  if (_displaced_problem)
    _displaced_problem->residualSetup();
}

resizeMaterialData()

void FEProblemBase::resizeMaterialData ( Moose::MaterialDataType  data_type, unsigned int  nqp, const THREAD_ID  tid  )

inherited

Resize material data.

Parameters

data_type	The type of material data to resize
nqp	The number of quadrature points to resize for
tid	The thread ID

Definition at line 9356 of file FEProblemBase.C.

{
  getMaterialData(data_type, tid).resize(nqp);
}

restartableName()

std::string Restartable::restartableName ( const std::string &  data_name ) const

protectedinherited

Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

This should only be used in this interface and in testing.

Definition at line 78 of file Restartable.C.

Referenced by Restartable::declareRecoverableData(), and Restartable::declareRestartableDataHelper().

{
  return _restartable_system_name + "/" + _restartable_name + "/" + data_name;
}

restoreMultiApps()

void FEProblemBase::restoreMultiApps ( ExecFlagType  type, bool  force = false  )

inherited

Restore the MultiApps associated with the ExecFlagType.

Parameters

force

Force restoration because something went wrong with the solve

Definition at line 5767 of file FEProblemBase.C.

Referenced by TransientBase::incrementStepOrReject(), and FixedPointSolve::solve().

{
  const auto & multi_apps = _multi_apps[type].getActiveObjects();

  if (multi_apps.size())
  {
    if (_verbose_multiapps)
    {
      if (force)
        _console << COLOR_CYAN << "\nRestoring Multiapps on " << type.name()
                 << " because of solve failure!" << COLOR_DEFAULT << std::endl;
      else
        _console << COLOR_CYAN << "\nRestoring MultiApps on " << type.name() << COLOR_DEFAULT
                 << std::endl;
    }

    for (const auto & multi_app : multi_apps)
      multi_app->restore(force);

    MooseUtils::parallelBarrierNotify(_communicator, _parallel_barrier_messaging);

    if (_verbose_multiapps)
      _console << COLOR_CYAN << "Finished Restoring MultiApps on " << type.name() << "\n"
               << COLOR_DEFAULT << std::endl;
  }
}

restoreOldSolutions()

void FEProblemBase::restoreOldSolutions ( )

virtualinherited

Restore old solutions from the backup vectors and deallocate them.

Definition at line 6917 of file FEProblemBase.C.

Referenced by EigenExecutionerBase::inversePowerIteration().

{
  TIME_SECTION("restoreOldSolutions", 5, "Restoring Old Solutions");

  for (auto & sys : _solver_systems)
    sys->restoreOldSolutions();
  _aux->restoreOldSolutions();
}

restoreOriginalNonzeroPattern()

bool FEProblemBase::restoreOriginalNonzeroPattern ( ) const

inlineinherited

Returns

Whether the original matrix nonzero pattern is restored before each Jacobian assembly

Definition at line 2145 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::computeJacobianInternal().

{ return _restore_original_nonzero_pattern; }

restoreSolutions()

void FEProblemBase::restoreSolutions ( )

virtualinherited

Definition at line 6879 of file FEProblemBase.C.

Referenced by ActivateElementsUserObjectBase::initSolutions(), TimeStepper::rejectStep(), and FEProblemBase::updateMeshXFEM().

{
  TIME_SECTION("restoreSolutions", 5, "Restoring Solutions");

  if (!_not_zeroed_tagged_vectors.empty())
    paramError("not_zeroed_tag_vectors",
               "There is currently no way to restore not-zeroed vectors.");

  for (auto & sys : _solver_systems)
  {
    if (_verbose_restore)
      _console << "Restoring solutions on system " << sys->name() << "..." << std::endl;
    sys->restoreSolutions();
  }

  if (_verbose_restore)
    _console << "Restoring solutions on Auxiliary system..." << std::endl;
  _aux->restoreSolutions();

  if (_verbose_restore)
    _console << "Restoring postprocessor, vector-postprocessor, and reporter data..." << std::endl;
  _reporter_data.restoreState(_verbose_restore);

  if (_displaced_problem)
    _displaced_problem->updateMesh();
}

safeAccessTaggedMatrices()

virtual bool SubProblem::safeAccessTaggedMatrices ( ) const

inlinevirtualinherited

Is it safe to access the tagged matrices.

Reimplemented in DisplacedProblem.

Definition at line 731 of file SubProblem.h.

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

{ return _safe_access_tagged_matrices; }

safeAccessTaggedVectors()

virtual bool SubProblem::safeAccessTaggedVectors ( ) const

inlinevirtualinherited

Is it safe to access the tagged vectors.

Reimplemented in DisplacedProblem.

Definition at line 734 of file SubProblem.h.

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

{ return _safe_access_tagged_vectors; }

saveOldSolutions()

void FEProblemBase::saveOldSolutions ( )

virtualinherited

Allocate vectors and save old solutions into them.

Definition at line 6907 of file FEProblemBase.C.

Referenced by EigenExecutionerBase::inversePowerIteration().

{
  TIME_SECTION("saveOldSolutions", 5, "Saving Old Solutions");

  for (auto & sys : _solver_systems)
    sys->saveOldSolutions();
  _aux->saveOldSolutions();
}

selectMatrixTagsFromSystem()

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

staticinherited

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 301 of file SubProblem.C.

Referenced by FEProblemBase::computeLinearSystemSys().

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

selectVectorTagsFromSystem()

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

staticinherited

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 290 of file SubProblem.C.

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

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

setActiveElementalMooseVariables()

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

overridevirtualinherited

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 from SubProblem.

Definition at line 6054 of file FEProblemBase.C.

Referenced by FEProblemBase::prepareMaterials(), ComputeMarkerThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), ComputeMaterialsObjectThread::subdomainChanged(), ComputeDiracThread::subdomainChanged(), NonlinearThread::subdomainChanged(), and ComputeUserObjectsThread::subdomainChanged().

{
  SubProblem::setActiveElementalMooseVariables(moose_vars, tid);

  if (_displaced_problem)
    _displaced_problem->setActiveElementalMooseVariables(moose_vars, tid);
}

setActiveFEVariableCoupleableMatrixTags()

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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6016 of file FEProblemBase.C.

{
  SubProblem::setActiveFEVariableCoupleableMatrixTags(mtags, tid);

  if (_displaced_problem)
    _displaced_problem->setActiveFEVariableCoupleableMatrixTags(mtags, tid);
}

setActiveFEVariableCoupleableVectorTags()

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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6025 of file FEProblemBase.C.

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute(), ComputeNodalKernelBcsThread::onNode(), ComputeNodalKernelsThread::onNode(), ComputeNodalUserObjectsThread::subdomainChanged(), ComputeMaterialsObjectThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), NonlinearThread::subdomainChanged(), and ComputeUserObjectsThread::subdomainChanged().

{
  SubProblem::setActiveFEVariableCoupleableVectorTags(vtags, tid);

  if (_displaced_problem)
    _displaced_problem->setActiveFEVariableCoupleableVectorTags(vtags, tid);
}

setActiveMaterialProperties()

void FEProblemBase::setActiveMaterialProperties ( const std::unordered_set< unsigned int > &  mat_prop_ids, const THREAD_ID  tid  )

inherited

Record and set the material properties required by the current computing thread.

Parameters

mat_prop_ids	The set of material properties required by the current computing thread.
tid	The thread id

Definition at line 6109 of file FEProblemBase.C.

Referenced by Moose::Mortar::loopOverMortarSegments(), FEProblemBase::prepareMaterials(), NodalPatchRecovery::reinitPatch(), NonlinearSystemBase::setConstraintSecondaryValues(), and ComputeDiracThread::subdomainChanged().

{
  // mark active properties in every material
  for (auto & mat : _all_materials.getObjects(tid))
    mat->setActiveProperties(mat_prop_ids);
  for (auto & mat : _all_materials[Moose::FACE_MATERIAL_DATA].getObjects(tid))
    mat->setActiveProperties(mat_prop_ids);
  for (auto & mat : _all_materials[Moose::NEIGHBOR_MATERIAL_DATA].getObjects(tid))
    mat->setActiveProperties(mat_prop_ids);

  _has_active_material_properties[tid] = !mat_prop_ids.empty();
}

setActiveScalarVariableCoupleableMatrixTags()

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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6034 of file FEProblemBase.C.

Referenced by AuxiliarySystem::setScalarVariableCoupleableTags().

{
  SubProblem::setActiveScalarVariableCoupleableMatrixTags(mtags, tid);

  if (_displaced_problem)
    _displaced_problem->setActiveScalarVariableCoupleableMatrixTags(mtags, tid);
}

setActiveScalarVariableCoupleableVectorTags()

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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6044 of file FEProblemBase.C.

Referenced by AuxiliarySystem::setScalarVariableCoupleableTags().

{
  SubProblem::setActiveScalarVariableCoupleableVectorTags(vtags, tid);

  if (_displaced_problem)
    _displaced_problem->setActiveScalarVariableCoupleableVectorTags(vtags, tid);
}

setAxisymmetricCoordAxis()

void FEProblemBase::setAxisymmetricCoordAxis ( const MooseEnum &  rz_coord_axis )

inherited

Definition at line 845 of file FEProblemBase.C.

{
  _mesh.setAxisymmetricCoordAxis(rz_coord_axis);
}

setChainControlDataOutput()

void SubProblem::setChainControlDataOutput ( bool  set_output )

inlineinherited

Setter for debug chain control data output.

Definition at line 926 of file SubProblem.h.

{ _show_chain_control_data = set_output; }

setConstJacobian()

void FEProblemBase::setConstJacobian ( bool  state )

inlineinherited

Set flag that Jacobian is constant (for optimization purposes)

Parameters

state

True if the Jacobian is constant, false otherwise

Definition at line 1993 of file FEProblemBase.h.

Referenced by ExplicitEuler::preSolve(), ExplicitTVDRK2::preSolve(), and ExplicitRK2::preSolve().

{ _const_jacobian = state; }

setCoordSystem()

void FEProblemBase::setCoordSystem ( const std::vector< SubdomainName > &  blocks, const MultiMooseEnum &  coord_sys  )

inherited

Definition at line 837 of file FEProblemBase.C.

{
  TIME_SECTION("setCoordSystem", 5, "Setting Coordinate System");
  _mesh.setCoordSystem(blocks, coord_sys);
}

setCoupling()

void FEProblemBase::setCoupling ( Moose::CouplingType  type )

inherited

Set the coupling between variables TODO: allow user-defined coupling.

Parameters

type	Type of coupling

Definition at line 6285 of file FEProblemBase.C.

Referenced by FEProblemBase::init(), FEProblemBase::setCouplingMatrix(), and Moose::SlepcSupport::setEigenProblemSolverParams().

{
  if (_trust_user_coupling_matrix)
  {
    if (_coupling != Moose::COUPLING_CUSTOM)
      mooseError("Someone told us (the FEProblemBase) to trust the user coupling matrix, but we "
                 "haven't been provided a coupling matrix!");

    // We've been told to trust the user coupling matrix, so we're going to leave things alone
    return;
  }

  _coupling = type;
}

setCouplingMatrix() [1/2]

void FEProblemBase::setCouplingMatrix ( std::unique_ptr< libMesh::CouplingMatrix >  cm, const unsigned int  nl_sys_num  )

inherited

Set custom coupling matrix.

Parameters

cm	coupling matrix to be set
nl_sys_num	which nonlinear system we are setting the coupling matrix for

Definition at line 6309 of file FEProblemBase.C.

Referenced by MoosePreconditioner::setCouplingMatrix().

{
  setCoupling(Moose::COUPLING_CUSTOM);
  _cm[i] = std::move(cm);
}

setCouplingMatrix() [2/2]

void FEProblemBase::setCouplingMatrix ( libMesh::CouplingMatrix *  cm, const unsigned int  nl_sys_num  )

inherited

Definition at line 6301 of file FEProblemBase.C.

{
  // TODO: Deprecate method
  setCoupling(Moose::COUPLING_CUSTOM);
  _cm[i].reset(cm);
}

setCurrentAlgebraicBndNodeRange()

void FEProblemBase::setCurrentAlgebraicBndNodeRange ( ConstBndNodeRange *  range )

inherited

Definition at line 9652 of file FEProblemBase.C.

{
  if (!range)
  {
    _current_algebraic_bnd_node_range = nullptr;
    return;
  }

  _current_algebraic_bnd_node_range = std::make_unique<ConstBndNodeRange>(*range);
}

setCurrentAlgebraicElementRange()

void FEProblemBase::setCurrentAlgebraicElementRange ( libMesh::ConstElemRange *  range )

inherited

These functions allow setting custom ranges for the algebraic elements, nodes, and boundary nodes that contribute to the jacobian and residual for this local processor.

setCurrentAlgebraicElementRange() sets the element range that contributes to the system. A nullptr will reset the range to use the mesh's range.

setCurrentAlgebraicNodeRange() sets the node range that contributes to the system. A nullptr will reset the range to use the mesh's range.

setCurrentAlgebraicBndNodeRange() sets the boundary node range that contributes to the system. A nullptr will reset the range to use the mesh's range.

Parameters

range

A pointer to the const range object representing the algebraic elements, nodes, or boundary nodes.

Definition at line 9630 of file FEProblemBase.C.

{
  if (!range)
  {
    _current_algebraic_elem_range = nullptr;
    return;
  }

  _current_algebraic_elem_range = std::make_unique<ConstElemRange>(*range);
}

setCurrentAlgebraicNodeRange()

void FEProblemBase::setCurrentAlgebraicNodeRange ( libMesh::ConstNodeRange *  range )

inherited

Definition at line 9641 of file FEProblemBase.C.

{
  if (!range)
  {
    _current_algebraic_node_range = nullptr;
    return;
  }

  _current_algebraic_node_range = std::make_unique<ConstNodeRange>(*range);
}

setCurrentBoundaryID()

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

overridevirtualinherited

sets the current boundary ID in assembly

Reimplemented from SubProblem.

Definition at line 9566 of file FEProblemBase.C.

{
  SubProblem::setCurrentBoundaryID(bid, tid);
  if (_displaced_problem)
    _displaced_problem->setCurrentBoundaryID(bid, tid);
}

setCurrentExecuteOnFlag()

void FEProblemBase::setCurrentExecuteOnFlag ( const ExecFlagType &  flag )

inherited

Definition at line 4784 of file FEProblemBase.C.

Referenced by FEProblemBase::execute(), FEProblemBase::initialSetup(), and FEProblemBase::outputStep().

{
  _current_execute_on_flag = flag;
}

setCurrentLinearSystem()

void FEProblemBase::setCurrentLinearSystem ( unsigned int  sys_num )

inherited

Set the current linear system pointer.

Parameters

sys_num

The number of linear system

Definition at line 9583 of file FEProblemBase.C.

Referenced by FEProblemBase::computeLinearSystemSys(), LinearSystem::computeLinearSystemTags(), and FEProblemBase::solveLinearSystem().

{
  mooseAssert(sys_num < _linear_systems.size(),
              "System number greater than the number of linear systems");
  _current_linear_sys = _linear_systems[sys_num].get();
  _current_solver_sys = _current_linear_sys;
}

setCurrentLowerDElem()

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

overridevirtualinherited

Set the current lower dimensional element.

This can be null

Reimplemented from SubProblem.

Definition at line 9557 of file FEProblemBase.C.

{
  SubProblem::setCurrentLowerDElem(lower_d_elem, tid);
  if (_displaced_problem)
    _displaced_problem->setCurrentLowerDElem(
        lower_d_elem ? _displaced_mesh->elemPtr(lower_d_elem->id()) : nullptr, tid);
}

setCurrentlyComputingJacobian()

void SubProblem::setCurrentlyComputingJacobian ( const bool  currently_computing_jacobian )

inlineinherited

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

Definition at line 689 of file SubProblem.h.

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

  {
    _currently_computing_jacobian = currently_computing_jacobian;
  }

setCurrentlyComputingResidual()

void FEProblemBase::setCurrentlyComputingResidual ( bool  currently_computing_residual )

finalvirtualinherited

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

Reimplemented from SubProblem.

Definition at line 9237 of file FEProblemBase.C.

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

{
  if (_displaced_problem)
    _displaced_problem->setCurrentlyComputingResidual(currently_computing_residual);
  _currently_computing_residual = currently_computing_residual;
}

setCurrentlyComputingResidualAndJacobian()

void SubProblem::setCurrentlyComputingResidualAndJacobian ( bool  currently_computing_residual_and_jacobian )

inlineinherited

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

Definition at line 1498 of file SubProblem.h.

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

{
  _currently_computing_residual_and_jacobian = currently_computing_residual_and_jacobian;
}

setCurrentNonlinearSystem()

void FEProblemBase::setCurrentNonlinearSystem ( const unsigned int  nl_sys_num )

inherited

Definition at line 9574 of file FEProblemBase.C.

Referenced by FEProblemBase::computeJacobian(), EigenProblem::computeJacobianAB(), EigenProblem::computeJacobianBlocks(), FEProblemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), EigenProblem::computeJacobianTag(), EigenProblem::computeMatricesTags(), EigenProblem::computeResidualTag(), NonlinearSystemBase::computeResidualTags(), FEProblem::FEProblem(), EigenProblem::solve(), and FEProblemBase::solve().

{
  mooseAssert(nl_sys_num < _nl.size(),
              "System number greater than the number of nonlinear systems");
  _current_nl_sys = _nl[nl_sys_num].get();
  _current_solver_sys = _current_nl_sys;
}

setCurrentResidualVectorTags()

void FEProblemBase::setCurrentResidualVectorTags ( const std::set< TagID > &  vector_tags )

inlineinherited

Set the current residual vector tag data structure based on the passed in tag IDs.

Definition at line 3547 of file FEProblemBase.h.

Referenced by FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), and CrankNicolson::init().

{
  _current_residual_vector_tags = getVectorTags(vector_tags);
}

setCurrentSubdomainID()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 1822 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), ElementalVariableValue::execute(), and ComputeInitialConditionThread::operator()().

{
  SubdomainID did = elem->subdomain_id();
  for (const auto i : index_range(_solver_systems))
  {
    _assembly[tid][i]->setCurrentSubdomainID(did);
    if (_displaced_problem &&
        (_reinit_displaced_elem || _reinit_displaced_face || _reinit_displaced_neighbor))
      _displaced_problem->assembly(tid, i).setCurrentSubdomainID(did);
  }
}

setDevice()

void MFEMProblem::setDevice

(

)

Set the device to use to solve the FE problem.

setErrorOnJacobianNonzeroReallocation()

void FEProblemBase::setErrorOnJacobianNonzeroReallocation ( bool  state )

inlineinherited

Definition at line 2156 of file FEProblemBase.h.

  {
    _error_on_jacobian_nonzero_reallocation = state;
  }

setException()

void FEProblemBase::setException ( const std::string &  message )

virtualinherited

Set an exception, which is stored at this point by toggling a member variable in this class, and which must be followed up with by a call to checkExceptionAndStopSolve().

Parameters

message

The error message describing the exception, which will get printed when checkExceptionAndStopSolve() is called

Definition at line 6659 of file FEProblemBase.C.

Referenced by ComputeThreadedGeneralUserObjectsThread::caughtMooseException(), ThreadedNodeLoop< ConstBndNodeRange, ConstBndNodeRange::const_iterator >::caughtMooseException(), ThreadedFaceLoop< RangeType >::caughtMooseException(), NonlinearSystemBase::computeDamping(), AuxiliarySystem::computeElementalVarsHelper(), AuxiliarySystem::computeMortarNodalVars(), FEProblemBase::handleException(), ComputeMortarFunctor::operator()(), and DisplacedProblem::updateMesh().

{
  _has_exception = true;
  _exception_message = message;
}

setExecutionPrinting()

void FEProblemBase::setExecutionPrinting ( const ExecFlagEnum &  print_exec )

inlineinherited

Definition at line 2629 of file FEProblemBase.h.

{ _print_execution_on = print_exec; }

setFailNextNonlinearConvergenceCheck()

void FEProblemBase::setFailNextNonlinearConvergenceCheck ( )

inlineinherited

Skip further residual evaluations and fail the next nonlinear convergence check(s)

Definition at line 2616 of file FEProblemBase.h.

Referenced by Terminator::execute().

{ setFailNextSystemConvergenceCheck(); }

setFailNextSystemConvergenceCheck()

void FEProblemBase::setFailNextSystemConvergenceCheck ( )

inlineinherited

Tell the problem that the system(s) cannot be considered converged next time convergence is checked.

Definition at line 2618 of file FEProblemBase.h.

Referenced by FEProblemBase::setFailNextNonlinearConvergenceCheck().

{ _fail_next_system_convergence_check = true; }

setFunctorOutput()

void SubProblem::setFunctorOutput ( bool  set_output )

inlineinherited

Setter for debug functor output.

Definition at line 924 of file SubProblem.h.

{ _show_functors = set_output; }

setIgnoreZerosInJacobian()

void FEProblemBase::setIgnoreZerosInJacobian ( bool  state )

inlineinherited

Set whether the zeros in the Jacobian should be dropped from the sparsity pattern.

Definition at line 2179 of file FEProblemBase.h.

{ _ignore_zeros_in_jacobian = state; }

setInputParametersFEProblem()

virtual void FEProblemBase::setInputParametersFEProblem ( InputParameters &  parameters )

inlinevirtualinherited

Reimplemented in FEProblem.

Definition at line 915 of file FEProblemBase.h.

Referenced by FEProblem::setInputParametersFEProblem().

  {
    parameters.set<FEProblemBase *>("_fe_problem_base") = this;
  }

setKernelCoverageCheck() [1/2]

void FEProblemBase::setKernelCoverageCheck ( CoverageCheckMode  mode )

inlineinherited

Set flag to indicate whether kernel coverage checks should be performed.

This check makes sure that at least one kernel is active on all subdomains in the domain (default: true).

Definition at line 1999 of file FEProblemBase.h.

{ _kernel_coverage_check = mode; }

setKernelCoverageCheck() [2/2]

void FEProblemBase::setKernelCoverageCheck ( bool  flag )

inlineinherited

Set flag to indicate whether kernel coverage checks should be performed.

This check makes sure that at least one kernel is active on all subdomains in the domain (default: true).

Definition at line 2005 of file FEProblemBase.h.

  {
    _kernel_coverage_check = flag ? CoverageCheckMode::TRUE : CoverageCheckMode::FALSE;
  }

setLinearConvergenceNames()

void FEProblemBase::setLinearConvergenceNames ( const std::vector< ConvergenceName > &  convergence_names )

inherited

Sets the linear convergence object name(s) if there is one.

Definition at line 9401 of file FEProblemBase.C.

Referenced by FEProblemSolve::FEProblemSolve().

{
  if (convergence_names.size() != numLinearSystems())
    paramError("linear_convergence", "There must be one convergence object per linear system");
  _linear_convergence_names = convergence_names;
}

setMaterialCoverageCheck() [1/2]

void FEProblemBase::setMaterialCoverageCheck ( CoverageCheckMode  mode )

inlineinherited

Set flag to indicate whether material coverage checks should be performed.

This check makes sure that at least one material is active on all subdomains in the domain if any material is supplied. If no materials are supplied anywhere, a simulation is still considered OK as long as no properties are being requested anywhere.

Definition at line 2016 of file FEProblemBase.h.

{ _material_coverage_check = mode; }

setMaterialCoverageCheck() [2/2]

void FEProblemBase::setMaterialCoverageCheck ( bool  flag )

inlineinherited

Set flag to indicate whether material coverage checks should be performed.

This check makes sure that at least one material is active on all subdomains in the domain if any material is supplied. If no materials are supplied anywhere, a simulation is still considered OK as long as no properties are being requested anywhere.

Definition at line 2024 of file FEProblemBase.h.

  {
    _material_coverage_check = flag ? CoverageCheckMode::TRUE : CoverageCheckMode::FALSE;
  }

setMesh()

void MFEMProblem::setMesh

(

)

Set the mesh used by MFEM.

Definition at line 50 of file MFEMProblem.C.

Referenced by MFEMProblem().

{
  auto pmesh = mesh().getMFEMParMeshPtr();
  getProblemData().pmesh = pmesh;
  getProblemData().comm = pmesh->GetComm();
  getProblemData().num_procs = pmesh->GetNRanks();
  getProblemData().myid = pmesh->GetMyRank();
}

setMultiAppFixedPointConvergenceName()

void FEProblemBase::setMultiAppFixedPointConvergenceName ( const ConvergenceName &  convergence_name )

inherited

Sets the MultiApp fixed point convergence object name if there is one.

Definition at line 9373 of file FEProblemBase.C.

Referenced by FixedPointSolve::FixedPointSolve().

{
  _multiapp_fixed_point_convergence_name = convergence_name;
}

setNeedToAddDefaultMultiAppFixedPointConvergence()

void FEProblemBase::setNeedToAddDefaultMultiAppFixedPointConvergence ( )

inlineinherited

Sets _need_to_add_default_multiapp_fixed_point_convergence to true.

Definition at line 684 of file FEProblemBase.h.

Referenced by FixedPointSolve::FixedPointSolve().

  {
    _need_to_add_default_multiapp_fixed_point_convergence = true;
  }

setNeedToAddDefaultNonlinearConvergence()

void FEProblemBase::setNeedToAddDefaultNonlinearConvergence ( )

inlineinherited

Sets _need_to_add_default_nonlinear_convergence to true.

Definition at line 679 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

  {
    _need_to_add_default_nonlinear_convergence = true;
  }

setNeedToAddDefaultSteadyStateConvergence()

void FEProblemBase::setNeedToAddDefaultSteadyStateConvergence ( )

inlineinherited

Sets _need_to_add_default_steady_state_convergence to true.

Definition at line 689 of file FEProblemBase.h.

Referenced by TransientBase::TransientBase().

  {
    _need_to_add_default_steady_state_convergence = true;
  }

setNeighborSubdomainID() [1/2]

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

overridevirtualinherited

Implements SubProblem.

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

setNeighborSubdomainID() [2/2]

virtual void FEProblemBase::setNeighborSubdomainID ( const Elem *  elem, const THREAD_ID  tid  )

virtualinherited

setNonlinearConvergenceNames()

void FEProblemBase::setNonlinearConvergenceNames ( const std::vector< ConvergenceName > &  convergence_names )

inherited

Sets the nonlinear convergence object name(s) if there is one.

Definition at line 9364 of file FEProblemBase.C.

Referenced by FEProblemSolve::FEProblemSolve().

{
  if (convergence_names.size() != numNonlinearSystems())
    paramError("nonlinear_convergence",
               "There must be one convergence object per nonlinear system");
  _nonlinear_convergence_names = convergence_names;
}

setNonlocalCouplingMatrix()

void FEProblemBase::setNonlocalCouplingMatrix ( )

inherited

Set custom coupling matrix for variables requiring nonlocal contribution.

Definition at line 6326 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

{
  TIME_SECTION("setNonlocalCouplingMatrix", 5, "Setting Nonlocal Coupling Matrix");

  if (_nl.size() > 1)
    mooseError("Nonlocal kernels are weirdly stored on the FEProblem so we don't currently support "
               "multiple nonlinear systems with nonlocal kernels.");

  for (const auto nl_sys_num : index_range(_nl))
  {
    auto & nl = _nl[nl_sys_num];
    auto & nonlocal_cm = _nonlocal_cm[nl_sys_num];
    unsigned int n_vars = nl->nVariables();
    nonlocal_cm.resize(n_vars);
    const auto & vars = nl->getVariables(0);
    const auto & nonlocal_kernel = _nonlocal_kernels.getObjects();
    const auto & nonlocal_integrated_bc = _nonlocal_integrated_bcs.getObjects();
    for (const auto & ivar : vars)
    {
      for (const auto & kernel : nonlocal_kernel)
      {
        for (unsigned int i = ivar->number(); i < ivar->number() + ivar->count(); ++i)
          if (i == kernel->variable().number())
            for (const auto & jvar : vars)
            {
              const auto it = _var_dof_map.find(jvar->name());
              if (it != _var_dof_map.end())
              {
                unsigned int j = jvar->number();
                nonlocal_cm(i, j) = 1;
              }
            }
      }
      for (const auto & integrated_bc : nonlocal_integrated_bc)
      {
        for (unsigned int i = ivar->number(); i < ivar->number() + ivar->count(); ++i)
          if (i == integrated_bc->variable().number())
            for (const auto & jvar : vars)
            {
              const auto it = _var_dof_map.find(jvar->name());
              if (it != _var_dof_map.end())
              {
                unsigned int j = jvar->number();
                nonlocal_cm(i, j) = 1;
              }
            }
      }
    }
  }
}

setParallelBarrierMessaging()

void FEProblemBase::setParallelBarrierMessaging ( bool  flag )

inlineinherited

Toggle parallel barrier messaging (defaults to on).

Definition at line 2032 of file FEProblemBase.h.

{ _parallel_barrier_messaging = flag; }

setPostprocessorValueByName()

void FEProblemBase::setPostprocessorValueByName ( const PostprocessorName &  name, const PostprocessorValue &  value, std::size_t  t_index = 0  )

inherited

Set the value of a PostprocessorValue.

Parameters

name	The name of the post-processor
t_index	Flag for getting current (0), old (1), or older (2) values

Returns

The reference to the value at the given time index

Note: This method is only for setting values that already exist, the Postprocessor and PostprocessorInterface objects should be used rather than this method for creating and getting values within objects.

WARNING! This method should be used with caution. It exists to allow Transfers and other similar objects to modify Postprocessor values. It is not intended for general use.

Definition at line 4642 of file FEProblemBase.C.

Referenced by MultiAppPostprocessorTransfer::execute(), PIDTransientControl::execute(), FEProblemBase::joinAndFinalize(), SecantSolve::transformPostprocessors(), SteffensenSolve::transformPostprocessors(), and PicardSolve::transformPostprocessors().

{
  _reporter_data.setReporterValue<PostprocessorValue>(
      PostprocessorReporterName(name), value, t_index);
}

setPreserveMatrixSparsityPattern()

void FEProblemBase::setPreserveMatrixSparsityPattern ( bool  preserve )

inherited

Set whether the sparsity pattern of the matrices being formed during the solve (usually the Jacobian) should be preserved.

This global setting can be retrieved by kernels, notably those using AD, to decide whether to take additional care to preserve the sparsity pattern

Definition at line 3952 of file FEProblemBase.C.

{
  if (_ignore_zeros_in_jacobian && preserve)
    paramWarning(
        "ignore_zeros_in_jacobian",
        "We likely cannot preserve the sparsity pattern if ignoring zeros in the Jacobian, which "
        "leads to removing those entries from the Jacobian sparsity pattern");
  _preserve_matrix_sparsity_pattern = preserve;
}

setResidual() [1/2]

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

pure virtualinherited

setResidual() [2/2]

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

overridevirtualinherited

Definition at line 1956 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintResiduals().

{
  _assembly[tid][_current_nl_sys->number()]->setResidual(
      residual,
      Assembly::GlobalDataKey{},
      getVectorTag(_nl[_current_nl_sys->number()]->residualVectorTag()));
  if (_displaced_problem)
    _displaced_problem->setResidual(residual, tid);
}

setResidualNeighbor() [1/2]

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

pure virtualinherited

setResidualNeighbor() [2/2]

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

overridevirtualinherited

Definition at line 1967 of file FEProblemBase.C.

{
  _assembly[tid][_current_nl_sys->number()]->setResidualNeighbor(
      residual, Assembly::GlobalDataKey{}, getVectorTag(_current_nl_sys->residualVectorTag()));
  if (_displaced_problem)
    _displaced_problem->setResidualNeighbor(residual, tid);
}

setRestartFile()

void FEProblemBase::setRestartFile ( const std::string &  file_name )

inherited

Communicate to the Resurector the name of the restart filer.

Parameters

file_name

The file name for restarting from

Definition at line 8876 of file FEProblemBase.C.

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

{
  if (_app.isRecovering())
  {
    mooseInfo("Restart file ", file_name, " is NOT being used since we are performing recovery.");
  }
  else
  {
    _app.setRestart(true);
    _app.setRestartRecoverFileBase(file_name);
    mooseInfo("Using ", file_name, " for restart.");
  }
}

setSNESMFReuseBase()

void FEProblemBase::setSNESMFReuseBase ( bool  reuse, bool  set_by_user  )

inlineinherited

If or not to reuse the base vector for matrix-free calculation.

Definition at line 2318 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

  {
    _snesmf_reuse_base = reuse, _snesmf_reuse_base_set_by_user = set_by_user;
  }

setSteadyStateConvergenceName()

void FEProblemBase::setSteadyStateConvergenceName ( const ConvergenceName &  convergence_name )

inherited

Sets the steady-state detection convergence object name if there is one.

Definition at line 9379 of file FEProblemBase.C.

Referenced by TransientBase::TransientBase().

{
  _steady_state_convergence_name = convergence_name;
}

setUDotDotOldRequested()

virtual void FEProblemBase::setUDotDotOldRequested ( const bool  u_dotdot_old_requested )

inlinevirtualinherited

Set boolean flag to true to store old solution second time derivative.

Definition at line 2366 of file FEProblemBase.h.

Referenced by CentralDifference::CentralDifference(), and NewmarkBeta::NewmarkBeta().

  {
    _u_dotdot_old_requested = u_dotdot_old_requested;
  }

setUDotDotRequested()

virtual void FEProblemBase::setUDotDotRequested ( const bool  u_dotdot_requested )

inlinevirtualinherited

Set boolean flag to true to store solution second time derivative.

Definition at line 2354 of file FEProblemBase.h.

Referenced by CentralDifference::CentralDifference(), and NewmarkBeta::NewmarkBeta().

  {
    _u_dotdot_requested = u_dotdot_requested;
  }

setUDotOldRequested()

virtual void FEProblemBase::setUDotOldRequested ( const bool  u_dot_old_requested )

inlinevirtualinherited

Set boolean flag to true to store old solution time derivative.

Definition at line 2360 of file FEProblemBase.h.

Referenced by CentralDifference::CentralDifference(), and NewmarkBeta::NewmarkBeta().

  {
    _u_dot_old_requested = u_dot_old_requested;
  }

setUDotRequested()

virtual void FEProblemBase::setUDotRequested ( const bool  u_dot_requested )

inlinevirtualinherited

Set boolean flag to true to store solution time derivative.

Definition at line 2351 of file FEProblemBase.h.

Referenced by TimeIntegrator::TimeIntegrator().

{ _u_dot_requested = u_dot_requested; }

setupDampers()

void FEProblemBase::setupDampers ( )

inherited

Definition at line 5389 of file FEProblemBase.C.

{
  for (auto & nl : _nl)
    nl->setupDampers();
}

setVariableAllDoFMap()

void FEProblemBase::setVariableAllDoFMap ( const std::vector< const MooseVariableFEBase *> &  moose_vars )

inherited

Definition at line 1730 of file FEProblemBase.C.

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

{
  for (unsigned int i = 0; i < moose_vars.size(); ++i)
  {
    VariableName var_name = moose_vars[i]->name();
    auto & sys = _solver_systems[moose_vars[i]->sys().number()];
    sys->setVariableGlobalDoFs(var_name);
    _var_dof_map[var_name] = sys->getVariableGlobalDoFs();
  }
}

setVectorPostprocessorValueByName()

void FEProblemBase::setVectorPostprocessorValueByName ( const std::string &  object_name, const std::string &  vector_name, const VectorPostprocessorValue &  value, std::size_t  t_index = 0  )

inherited

Set the value of a VectorPostprocessor vector.

Parameters

object_name	The name of the VPP object
vector_name	The name of the declared vector
value	The data to apply to the vector
t_index	Flag for getting current (0), old (1), or older (2) values

Definition at line 4668 of file FEProblemBase.C.

{
  _reporter_data.setReporterValue<VectorPostprocessorValue>(
      VectorPostprocessorReporterName(object_name, vector_name), value, t_index);
}

setVerboseProblem()

void FEProblemBase::setVerboseProblem ( bool  verbose )

inherited

Make the problem be verbose.

Definition at line 9549 of file FEProblemBase.C.

Referenced by Executioner::Executioner(), and PhysicsBase::initializePhysics().

{
  _verbose_setup = verbose ? "true" : "false";
  _verbose_multiapps = verbose;
  _verbose_restore = verbose;
}

shouldPrintExecution()

bool FEProblemBase::shouldPrintExecution ( const THREAD_ID  tid ) const

inherited

Check whether the problem should output execution orders at this time.

Definition at line 9491 of file FEProblemBase.C.

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

{
  // For now, only support printing from thread 0
  if (tid != 0)
    return false;

  if (_print_execution_on.isValueSet(_current_execute_on_flag) ||
      _print_execution_on.isValueSet(EXEC_ALWAYS))
    return true;
  else
    return false;
}

shouldSolve()

bool FEProblemBase::shouldSolve ( ) const

inlineinherited

Definition at line 2402 of file FEProblemBase.h.

Referenced by ExternalProblem::solve(), FEProblemSolve::solve(), MFEMProblemSolve::solve(), and TransientBase::TransientBase().

{ return _solve; }

shouldUpdateSolution()

bool FEProblemBase::shouldUpdateSolution ( )

virtualinherited

Check to see whether the problem should update the solution.

Returns

true if the problem should update the solution, false otherwise

Definition at line 7993 of file FEProblemBase.C.

Referenced by FEProblemBase::computePostCheck(), and NonlinearSystem::solve().

{
  return false;
}

showInvalidSolutionConsole()

bool FEProblemBase::showInvalidSolutionConsole ( ) const

inlineinherited

Whether or not to print out the invalid solutions summary table in console.

Definition at line 2196 of file FEProblemBase.h.

Referenced by SolverSystem::checkInvalidSolution().

{ return _show_invalid_solution_console; }

sizeZeroes()

void FEProblemBase::sizeZeroes ( unsigned int  size, const THREAD_ID  tid  )

virtualinherited

Definition at line 2158 of file FEProblemBase.C.

{
  mooseDoOnce(mooseWarning(
      "This function is deprecated and no longer performs any function. Please do not call it."));
}

skipExceptionCheck()

void FEProblemBase::skipExceptionCheck ( bool  skip_exception_check )

inlineinherited

Set a flag that indicates if we want to skip exception and stop solve.

Definition at line 2331 of file FEProblemBase.h.

Referenced by FEProblemSolve::FEProblemSolve().

  {
    _skip_exception_check = skip_exception_check;
  }

solve()

void ExternalProblem::solve ( unsigned int  nl_sys_num = 0 )

finaloverridevirtualinherited

Solve is implemented to providing syncing to/from the "transfer" mesh.

Reimplemented from FEProblemBase.

Definition at line 61 of file ExternalProblem.C.

{
  TIME_SECTION("solve", 1, "Solving", false)

  syncSolutions(Direction::TO_EXTERNAL_APP);
  if (shouldSolve())
    externalSolve();
  syncSolutions(Direction::FROM_EXTERNAL_APP);
}

solveLinearSystem()

void FEProblemBase::solveLinearSystem ( const unsigned int  linear_sys_num, const Moose::PetscSupport::PetscOptions *  po = nullptr  )

virtualinherited

Build and solve a linear system.

Parameters

linear_sys_num	The number of the linear system (1,..,num. of lin. systems)
po	The petsc options for the solve, if not supplied, the defaults are used

Reimplemented in DumpObjectsProblem.

Definition at line 6755 of file FEProblemBase.C.

Referenced by FEProblemSolve::solve().

{
  TIME_SECTION("solve", 1, "Solving", false);

  setCurrentLinearSystem(linear_sys_num);

  const Moose::PetscSupport::PetscOptions & options = po ? *po : _petsc_options;
  auto & solver_params = _solver_params[numNonlinearSystems() + linear_sys_num];

  // Set custom convergence criteria
  Moose::PetscSupport::petscSetDefaults(*this);

#if PETSC_RELEASE_LESS_THAN(3, 12, 0)
  LibmeshPetscCall(Moose::PetscSupport::petscSetOptions(
      options, solver_params)); // Make sure the PETSc options are setup for this app
#else
  // Now this database will be the default
  // Each app should have only one database
  if (!_app.isUltimateMaster())
    LibmeshPetscCall(PetscOptionsPush(_petsc_option_data_base));

  // We did not add PETSc options to database yet
  if (!_is_petsc_options_inserted)
  {
    Moose::PetscSupport::petscSetOptions(options, solver_params, this);
    _is_petsc_options_inserted = true;
  }
#endif

  if (_solve)
    _current_linear_sys->solve();

#if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
  if (!_app.isUltimateMaster())
    LibmeshPetscCall(PetscOptionsPop());
#endif
}

solverParams() [1/2]

SolverParams & FEProblemBase::solverParams ( unsigned int  solver_sys_num = 0 )

inherited

Get the solver parameters.

Definition at line 8908 of file FEProblemBase.C.

Referenced by NonlinearEigenSystem::attachPreconditioner(), SolverSystem::compute(), SlepcEigenSolverConfiguration::configure_solver(), Eigenvalue::Eigenvalue(), ExplicitTimeIntegrator::ExplicitTimeIntegrator(), FEProblemSolve::FEProblemSolve(), ExplicitTimeIntegrator::init(), EigenProblem::init(), FEProblemBase::init(), EigenProblem::isNonlinearEigenvalueSolver(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionA(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionAB(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionB(), Moose::SlepcSupport::mooseSlepcEigenFormJacobianA(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), ConsoleUtils::outputExecutionInformation(), Moose::PetscSupport::petscSetDefaults(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), Eigenvalue::prepareSolverOptions(), NonlinearSystem::residualAndJacobianTogether(), Moose::SlepcSupport::setEigenProblemSolverParams(), Moose::PetscSupport::setLineSearchFromParams(), Moose::PetscSupport::setMFFDTypeFromParams(), Moose::PetscSupport::setSinglePetscOption(), Moose::PetscSupport::setSolveTypeFromParams(), NonlinearSystemBase::shouldEvaluatePreSMOResidual(), EigenProblem::solve(), FEProblemBase::solverParams(), EigenProblem::solverTypeString(), FEProblemBase::solverTypeString(), and Moose::SlepcSupport::storeSolveType().

{
  mooseAssert(solver_sys_num < numSolverSystems(),
              "Solver system number '" << solver_sys_num << "' is out of bounds. We have '"
                                       << numSolverSystems() << "' solver systems");
  return _solver_params[solver_sys_num];
}

solverParams() [2/2]

const SolverParams & FEProblemBase::solverParams ( unsigned int  solver_sys_num = 0 ) const

inherited

const version

Definition at line 8917 of file FEProblemBase.C.

{
  return const_cast<FEProblemBase *>(this)->solverParams(solver_sys_num);
}

solverSysNum()

unsigned int FEProblemBase::solverSysNum ( const SolverSystemName &  solver_sys_name ) const

overridevirtualinherited

Returns

the solver system number corresponding to the provided solver_sys_name

Implements SubProblem.

Definition at line 6562 of file FEProblemBase.C.

Referenced by FEProblemBase::addVariable(), FEProblemBase::getSystemBase(), MultiSystemSolveObject::MultiSystemSolveObject(), and DisplacedProblem::solverSysNum().

{
  std::istringstream ss(solver_sys_name);
  unsigned int solver_sys_num;
  if (!(ss >> solver_sys_num) || !ss.eof())
  {
    const auto & search = _solver_sys_name_to_num.find(solver_sys_name);
    if (search == _solver_sys_name_to_num.end())
      mooseError("The solver system number was requested for system '" + solver_sys_name,
                 "' but this system does not exist in the Problem. Systems can be added to the "
                 "problem using the 'nl_sys_names'/'linear_sys_names' parameter.\nSystems in the "
                 "Problem: " +
                     Moose::stringify(_solver_sys_names));
    solver_sys_num = search->second;
  }

  return solver_sys_num;
}

solverSystemConverged()

bool FEProblemBase::solverSystemConverged ( const unsigned int  sys_num )

overridevirtualinherited

Returns

whether the given solver system sys_num is converged

Reimplemented from SubProblem.

Reimplemented in EigenProblem.

Definition at line 6795 of file FEProblemBase.C.

{
  if (_solve)
    return _solver_systems[sys_num]->converged();
  else
    return true;
}

solverTypeString()

std::string MFEMProblem::solverTypeString ( unsigned int  solver_sys_num )

overridevirtual

Return solver type as a human readable string.

Reimplemented from FEProblemBase.

Definition at line 518 of file MFEMProblem.C.

{
  mooseAssert(solver_sys_num == 0, "No support for multi-system with MFEM right now");
  return MooseUtils::prettyCppType(getProblemData().jacobian_solver.get());
}

startedInitialSetup()

virtual bool FEProblemBase::startedInitialSetup ( )

inlinevirtualinherited

Returns true if we are in or beyond the initialSetup stage.

Definition at line 536 of file FEProblemBase.h.

Referenced by NEML2ModelExecutor::checkExecutionStage(), MaterialBase::checkExecutionStage(), and MaterialPropertyInterface::checkExecutionStage().

{ return _started_initial_setup; }

storeBoundaryDelayedCheckMatProp()

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

virtualinherited

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 616 of file SubProblem.C.

Referenced by MaterialPropertyInterface::checkMaterialProperty().

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

storeBoundaryMatPropName()

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

virtualinherited

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 590 of file SubProblem.C.

Referenced by MaterialBase::registerPropName().

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

storeBoundaryZeroMatProp()

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

virtualinherited

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 602 of file SubProblem.C.

Referenced by MaterialBase::storeBoundaryZeroMatProp().

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

storeSubdomainDelayedCheckMatProp()

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

virtualinherited

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 608 of file SubProblem.C.

Referenced by MaterialPropertyInterface::checkMaterialProperty().

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

storeSubdomainMatPropName()

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

virtualinherited

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 584 of file SubProblem.C.

Referenced by MaterialBase::registerPropName().

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

storeSubdomainZeroMatProp()

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

virtualinherited

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 596 of file SubProblem.C.

Referenced by MaterialBase::storeSubdomainZeroMatProp().

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

subdomainSetup()

void FEProblemBase::subdomainSetup ( SubdomainID  subdomain, const THREAD_ID  tid  )

virtualinherited

Definition at line 2521 of file FEProblemBase.C.

Referenced by ComputeMarkerThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), ComputeMaterialsObjectThread::subdomainChanged(), ComputeDiracThread::subdomainChanged(), NonlinearThread::subdomainChanged(), ComputeUserObjectsThread::subdomainChanged(), and ThreadedFaceLoop< RangeType >::subdomainChanged().

{
  _all_materials.subdomainSetup(subdomain, tid);
  // Call the subdomain methods of the output system, these are not threaded so only call it once
  if (tid == 0)
    _app.getOutputWarehouse().subdomainSetup();

  for (auto & nl : _nl)
    nl->subdomainSetup(subdomain, tid);

  // FIXME: call displaced_problem->subdomainSetup() ?
  //        When adding possibility with materials being evaluated on displaced mesh
}

subspaceDim()

unsigned int FEProblemBase::subspaceDim ( const std::string &  prefix ) const

inlineinherited

Dimension of the subspace spanned by vectors with a given prefix.

Parameters

prefix

Prefix of the vectors spanning the subspace.

Definition at line 2074 of file FEProblemBase.h.

Referenced by FEProblemBase::computeNearNullSpace(), FEProblemBase::computeNullSpace(), and FEProblemBase::computeTransposeNullSpace().

  {
    if (_subspace_dim.count(prefix))
      return _subspace_dim.find(prefix)->second;
    else
      return 0;
  }

swapBackMaterials()

void FEProblemBase::swapBackMaterials ( const THREAD_ID  tid )

virtualinherited

Definition at line 4354 of file FEProblemBase.C.

Referenced by NodalPatchRecovery::compute(), LineMaterialSamplerBase< Real >::execute(), ComputeMarkerThread::onElement(), ComputeElemAuxVarsThread< AuxKernelType >::onElement(), ComputeIndicatorThread::onElement(), NonlinearThread::onElement(), and ComputeUserObjectsThread::onElement().

{
  auto && elem = _assembly[tid][0]->elem();
  _material_props.getMaterialData(tid).swapBack(*elem);
}

swapBackMaterialsFace()

void FEProblemBase::swapBackMaterialsFace ( const THREAD_ID  tid )

virtualinherited

Definition at line 4361 of file FEProblemBase.C.

Referenced by NonlinearThread::onBoundary(), ComputeUserObjectsThread::onBoundary(), NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), NonlinearThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and ComputeElemAuxBcsThread< AuxKernelType >::operator()().

{
  auto && elem = _assembly[tid][0]->elem();
  unsigned int side = _assembly[tid][0]->side();
  _bnd_material_props.getMaterialData(tid).swapBack(*elem, side);
}

swapBackMaterialsNeighbor()

void FEProblemBase::swapBackMaterialsNeighbor ( const THREAD_ID  tid )

virtualinherited

Definition at line 4369 of file FEProblemBase.C.

Referenced by NonlinearThread::onInterface(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), NonlinearThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and ComputeElemAuxBcsThread< AuxKernelType >::operator()().

{
  // NOTE: this will not work with h-adaptivity
  const Elem * neighbor = _assembly[tid][0]->neighbor();
  unsigned int neighbor_side =
      neighbor ? neighbor->which_neighbor_am_i(_assembly[tid][0]->elem()) : libMesh::invalid_uint;

  if (!neighbor)
  {
    if (haveFV())
    {
      // If neighbor is null, then we're on the neighbor side of a mesh boundary, e.g. we're off
      // the mesh in ghost-land. If we're using the finite volume method, then variable values and
      // consequently material properties have well-defined values in this ghost region outside of
      // the mesh and we really do want to reinit our neighbor materials in this case. Since we're
      // off in ghost land it's safe to do swaps with `MaterialPropertyStorage` using the elem and
      // elem_side keys
      neighbor = _assembly[tid][0]->elem();
      neighbor_side = _assembly[tid][0]->side();
      mooseAssert(neighbor, "We should have an appropriate value for elem coming from Assembly");
    }
    else
      mooseError("neighbor is null in Assembly!");
  }

  _neighbor_material_props.getMaterialData(tid).swapBack(*neighbor, neighbor_side);
}

syncSolutions()

virtual void MFEMProblem::syncSolutions ( Direction  direction )

inlineoverridevirtual

Method to transfer data to/from the external application to the associated transfer mesh.

Implements ExternalProblem.

Definition at line 27 of file MFEMProblem.h.

{}

systemBaseAuxiliary() [1/2]

const SystemBase & FEProblemBase::systemBaseAuxiliary ( ) const

overridevirtualinherited

Return the auxiliary system object as a base class reference.

Implements SubProblem.

Definition at line 9215 of file FEProblemBase.C.

Referenced by PhysicsBase::copyVariablesFromMesh(), and getAuxVariableNames().

{
  return *_aux;
}

systemBaseAuxiliary() [2/2]

SystemBase & FEProblemBase::systemBaseAuxiliary ( )

overridevirtualinherited

Implements SubProblem.

Definition at line 9221 of file FEProblemBase.C.

{
  return *_aux;
}

systemBaseLinear() [1/2]

const SystemBase & FEProblemBase::systemBaseLinear ( unsigned int  sys_num ) const

overridevirtualinherited

Get a constant base class reference to a linear system.

Parameters

sys_num

The number of the linear system

Implements SubProblem.

Definition at line 9183 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _linear_systems.size(),
              "System number greater than the number of linear systems");
  return *_linear_systems[sys_num];
}

systemBaseLinear() [2/2]

SystemBase & FEProblemBase::systemBaseLinear ( unsigned int  sys_num )

overridevirtualinherited

Get a non-constant base class reference to a linear system.

Parameters

sys_num

The number of the linear system

Implements SubProblem.

Definition at line 9191 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _linear_systems.size(),
              "System number greater than the number of linear systems");
  return *_linear_systems[sys_num];
}

systemBaseNonlinear() [1/2]

const SystemBase & FEProblemBase::systemBaseNonlinear ( const unsigned int  sys_num ) const

overridevirtualinherited

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

Implements SubProblem.

Definition at line 9169 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
  return *_nl[sys_num];
}

systemBaseNonlinear() [2/2]

SystemBase & FEProblemBase::systemBaseNonlinear ( const unsigned int  sys_num )

overridevirtualinherited

Implements SubProblem.

Definition at line 9176 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
  return *_nl[sys_num];
}

systemBaseSolver() [1/2]

const SystemBase & FEProblemBase::systemBaseSolver ( const unsigned int  sys_num ) const

overridevirtualinherited

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

Implements SubProblem.

Definition at line 9199 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _solver_systems.size(),
              "System number greater than the number of solver systems");
  return *_solver_systems[sys_num];
}

systemBaseSolver() [2/2]

SystemBase & FEProblemBase::systemBaseSolver ( const unsigned int  sys_num )

overridevirtualinherited

Implements SubProblem.

Definition at line 9207 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _solver_systems.size(),
              "System number greater than the number of solver systems");
  return *_solver_systems[sys_num];
}

systemNumForVariable()

unsigned int FEProblemBase::systemNumForVariable ( const VariableName &  variable_name ) const

inherited

Returns

the system number for the provided variable_name Can be nonlinear or auxiliary

Definition at line 6582 of file FEProblemBase.C.

Referenced by FEProblemBase::projectFunctionOnCustomRange(), and ElementSubdomainModifierBase::restoreOverriddenDofValues().

{
  for (const auto & solver_sys : _solver_systems)
    if (solver_sys->hasVariable(variable_name))
      return solver_sys->number();
  mooseAssert(_aux, "Should have an auxiliary system");
  if (_aux->hasVariable(variable_name))
    return _aux->number();

  mooseError("Variable '",
             variable_name,
             "' was not found in any solver (nonlinear/linear) or auxiliary system");
}

terminateSolve()

virtual void Problem::terminateSolve ( )

inlinevirtualinherited

Allow objects to request clean termination of the solve.

Definition at line 37 of file Problem.h.

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

{ _termination_requested = true; };

theWarehouse()

TheWarehouse& FEProblemBase::theWarehouse ( ) const

inlineinherited

Definition at line 2313 of file FEProblemBase.h.

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addDGKernel(), NonlinearSystemBase::addDiracKernel(), NonlinearSystemBase::addHDGKernel(), NonlinearSystemBase::addInterfaceKernel(), NonlinearSystemBase::addKernel(), NonlinearSystemBase::addNodalKernel(), FEProblemBase::addObject(), NonlinearSystemBase::addScalarKernel(), NonlinearSystemBase::addSplit(), FEProblemBase::addUserObject(), NonlinearSystemBase::checkKernelCoverage(), FEProblemBase::checkUserObjectJacobianRequirement(), FEProblemBase::checkUserObjects(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::computeUserObjectByName(), FEProblemBase::computeUserObjects(), LinearSystem::containsTimeKernel(), NonlinearSystemBase::customSetup(), FEProblemBase::customSetup(), ComputeResidualThread::determineObjectWarehouses(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), FEProblemBase::executeSamplers(), ComputeLinearFVElementalThread::fetchBlockSystemContributionObjects(), ComputeLinearFVFaceThread::fetchBlockSystemContributionObjects(), FEProblemBase::getDistribution(), FEProblemBase::getMortarUserObjects(), FEProblemBase::getPositionsObject(), FEProblemBase::getSampler(), CompositionDT::getTimeSteppers(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), FEProblemBase::hasUserObject(), SideFVFluxBCIntegral::initialSetup(), ExplicitTimeIntegrator::initialSetup(), LinearSystem::initialSetup(), NonlinearSystemBase::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), FEProblemBase::needBoundaryMaterialOnSide(), FEProblemBase::needInterfaceMaterialOnSide(), FEProblemBase::needInternalNeighborSideMaterial(), JSONOutput::outputReporters(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), ComputeLinearFVElementalThread::setupSystemContributionObjects(), ComputeLinearFVFaceThread::setupSystemContributionObjects(), NonlinearThread::subdomainChanged(), NonlinearSystemBase::timestepSetup(), and FEProblemBase::timestepSetup().

{ return _app.theWarehouse(); }

time()

virtual Real& FEProblemBase::time ( ) const

inlinevirtualinherited

Definition at line 541 of file FEProblemBase.h.

Referenced by EigenExecutionerBase::EigenExecutionerBase(), PseudoTimestep::execute(), Times::getCurrentTime(), FEProblemBase::getTimeFromStateArg(), TimePostprocessor::getValue(), NonlinearEigen::init(), InversePowerMethod::init(), Moose::MFEM::TimeDomainEquationSystemProblemOperator::Init(), SimulationTimes::initialize(), MFEMSteady::MFEMSteady(), JSONOutput::outputReporters(), XMLOutput::outputVectorPostprocessors(), EigenExecutionerBase::postExecute(), ExplicitSSPRungeKutta::postResidual(), ActuallyExplicitEuler::postResidual(), Predictor::shouldApply(), ExplicitSSPRungeKutta::solve(), ActuallyExplicitEuler::solve(), FixedPointSolve::solve(), Moose::MFEM::TimeDomainEquationSystemProblemOperator::Solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), AStableDirk4::solve(), LStableDirk4::solve(), ExplicitRK2::solve(), FixedPointSolve::solveStep(), WebServerControl::startServer(), SteadyBase::SteadyBase(), and NumNonlinearIterations::timestepSetup().

{ return _time; }

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 47 of file PerfGraphInterface.C.

Referenced by PerfGraphInterface::registerTimedSection().

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

timeOld()

virtual Real& FEProblemBase::timeOld ( ) const

inlinevirtualinherited

Definition at line 542 of file FEProblemBase.h.

Referenced by EigenExecutionerBase::EigenExecutionerBase(), FEProblemBase::getTimeFromStateArg(), Predictor::shouldApply(), ExplicitSSPRungeKutta::solve(), ActuallyExplicitEuler::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), LStableDirk4::solve(), AStableDirk4::solve(), and ExplicitRK2::solve().

{ return _time_old; }

timeStep()

virtual int& FEProblemBase::timeStep ( ) const

inlinevirtualinherited

Definition at line 543 of file FEProblemBase.h.

Referenced by NewmarkBeta::computeTimeDerivatives(), EigenExecutionerBase::EigenExecutionerBase(), PseudoTimestep::execute(), NumTimeSteps::getValue(), NonlinearEigen::init(), InversePowerMethod::init(), PseudoTimestep::outputPseudoTimestep(), JSONOutput::outputReporters(), XMLOutput::outputVectorPostprocessors(), EigenExecutionerBase::postExecute(), TransientMultiApp::setupApp(), NonlinearSystem::solve(), PseudoTimestep::timestepEXP(), PseudoTimestep::timestepSER(), and RandomData::updateSeeds().

{ return _t_step; }

timestepSetup()

void FEProblemBase::timestepSetup ( )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 1537 of file FEProblemBase.C.

Referenced by MFEMSteady::execute(), SteadyBase::execute(), Eigenvalue::execute(), NonlinearEigen::takeStep(), MFEMTransient::takeStep(), and TransientBase::takeStep().

{
  SubProblem::timestepSetup();

  if (_t_step > 1 && _num_grid_steps)
  {
    libMesh::MeshRefinement mesh_refinement(_mesh);
    std::unique_ptr<libMesh::MeshRefinement> displaced_mesh_refinement(nullptr);
    if (_displaced_mesh)
      displaced_mesh_refinement = std::make_unique<libMesh::MeshRefinement>(*_displaced_mesh);

    for (MooseIndex(_num_grid_steps) i = 0; i < _num_grid_steps; ++i)
    {
      if (_displaced_problem)
        // If the DisplacedProblem is active, undisplace the DisplacedMesh in preparation for
        // refinement.  We can't safely refine the DisplacedMesh directly, since the Hilbert keys
        // computed on the inconsistenly-displaced Mesh are different on different processors,
        // leading to inconsistent Hilbert keys.  We must do this before the undisplaced Mesh is
        // coarsensed, so that the element and node numbering is still consistent. We also have to
        // make sure this is done during every step of coarsening otherwise different partitions
        // will be generated for the reference and displaced meshes (even for replicated)
        _displaced_problem->undisplaceMesh();

      mesh_refinement.uniformly_coarsen();
      if (_displaced_mesh)
        displaced_mesh_refinement->uniformly_coarsen();

      // Mark this as an intermediate change because we do not yet want to reinit_systems. E.g. we
      // need things to happen in the following order for the undisplaced problem:
      // u1) EquationSystems::reinit_solutions. This will restrict the solution vectors and then
      //     contract the mesh
      // u2) MooseMesh::meshChanged. This will update the node/side lists and other
      //     things which needs to happen after the contraction
      // u3) GeometricSearchData::reinit. Once the node/side lists are updated we can perform our
      //     geometric searches which will aid in determining sparsity patterns
      //
      // We do these things for the displaced problem (if it exists)
      // d1) EquationSystems::reinit. Restrict the displaced problem vector copies and then contract
      //     the mesh. It's safe to do a full reinit with the displaced because there are no
      //     matrices that sparsity pattern calculations will be conducted for
      // d2) MooseMesh::meshChanged. This will update the node/side lists and other
      //     things which needs to happen after the contraction
      // d3) UpdateDisplacedMeshThread::operator(). Re-displace the mesh using the *displaced*
      //     solution vector copy because we don't know the state of the reference solution vector.
      //     It's safe to use the displaced copy because we are outside of a non-linear solve,
      //     and there is no concern about differences between solution and current_local_solution
      // d4) GeometricSearchData::reinit. With the node/side lists updated and the mesh
      //     re-displaced, we can perform our geometric searches, which will aid in determining the
      //     sparsity pattern of the matrix held by the libMesh::ImplicitSystem held by the
      //     NonlinearSystem held by this
      meshChanged(
          /*intermediate_change=*/true, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
    }

    // u4) Now that all the geometric searches have been done (both undisplaced and displaced),
    //     we're ready to update the sparsity pattern
    es().reinit_systems();
  }

  if (_line_search)
    _line_search->timestepSetup();

  // Random interface objects
  for (const auto & it : _random_data_objects)
    it.second->updateSeeds(EXEC_TIMESTEP_BEGIN);

  unsigned int n_threads = libMesh::n_threads();
  for (THREAD_ID tid = 0; tid < n_threads; tid++)
  {
    _all_materials.timestepSetup(tid);
    _functions.timestepSetup(tid);
  }

  _aux->timestepSetup();
  for (auto & sys : _solver_systems)
    sys->timestepSetup();

  if (_displaced_problem)
    // timestepSetup for displaced systems
    _displaced_problem->timestepSetup();

  for (THREAD_ID tid = 0; tid < n_threads; tid++)
  {
    _internal_side_indicators.timestepSetup(tid);
    _indicators.timestepSetup(tid);
    _markers.timestepSetup(tid);
  }

  std::vector<UserObject *> userobjs;
  theWarehouse().query().condition<AttribSystem>("UserObject").queryIntoUnsorted(userobjs);
  for (auto obj : userobjs)
    obj->timestepSetup();

  // Timestep setup of output objects
  _app.getOutputWarehouse().timestepSetup();

  if (_requires_nonlocal_coupling)
    if (_nonlocal_kernels.hasActiveObjects() || _nonlocal_integrated_bcs.hasActiveObjects())
      _has_nonlocal_coupling = true;
}

transient()

virtual void FEProblemBase::transient ( bool  trans )

inlinevirtualinherited

Definition at line 551 of file FEProblemBase.h.

Referenced by EigenExecutionerBase::EigenExecutionerBase(), and TransientBase::TransientBase().

{ _transient = trans; }

trustUserCouplingMatrix()

void FEProblemBase::trustUserCouplingMatrix ( )

inherited

Whether to trust the user coupling matrix even if we want to do things like be paranoid and create a full coupling matrix.

See https://github.com/idaholab/moose/issues/16395 for detailed background

Definition at line 6316 of file FEProblemBase.C.

Referenced by SingleMatrixPreconditioner::SingleMatrixPreconditioner().

{
  if (_coupling != Moose::COUPLING_CUSTOM)
    mooseError("Someone told us (the FEProblemBase) to trust the user coupling matrix, but we "
               "haven't been provided a coupling matrix!");

  _trust_user_coupling_matrix = true;
}

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.

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

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

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.

Referenced by FEProblemBase::addPostprocessor(), MaterialPropertyStorage::addProperty(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< std::vector< T > >::finalize(), and ReporterData::getReporterInfo().

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

uDotDotOldRequested()

virtual bool FEProblemBase::uDotDotOldRequested ( )

inlinevirtualinherited

Get boolean flag to check whether old solution second time derivative needs to be stored.

Definition at line 2389 of file FEProblemBase.h.

Referenced by SystemBase::addDotVectors().

  {
    if (_u_dotdot_old_requested && !_u_dotdot_requested)
      mooseError("FEProblemBase: When requesting old second time derivative of solution, current "
                 "second time derivation of solution should also be stored. Please set "
                 "`u_dotdot_requested` to true using setUDotDotRequested.");
    return _u_dotdot_old_requested;
  }

uDotDotRequested()

virtual bool FEProblemBase::uDotDotRequested ( )

inlinevirtualinherited

Get boolean flag to check whether solution second time derivative needs to be stored.

Definition at line 2375 of file FEProblemBase.h.

Referenced by SystemBase::addDotVectors(), and FEProblemBase::addTimeIntegrator().

{ return _u_dotdot_requested; }

uDotOldRequested()

virtual bool FEProblemBase::uDotOldRequested ( )

inlinevirtualinherited

Get boolean flag to check whether old solution time derivative needs to be stored.

Definition at line 2378 of file FEProblemBase.h.

Referenced by SystemBase::addDotVectors().

  {
    if (_u_dot_old_requested && !_u_dot_requested)
      mooseError("FEProblemBase: When requesting old time derivative of solution, current time "
                 "derivative of solution should also be stored. Please set `u_dot_requested` to "
                 "true using setUDotRequested.");

    return _u_dot_old_requested;
  }

uDotRequested()

virtual bool FEProblemBase::uDotRequested ( )

inlinevirtualinherited

Get boolean flag to check whether solution time derivative needs to be stored.

Definition at line 2372 of file FEProblemBase.h.

Referenced by SystemBase::addDotVectors().

{ return _u_dot_requested; }

uniformRefine()

void FEProblemBase::uniformRefine ( )

inherited

uniformly refine the problem mesh(es).

This will also prolong the the solution, and in order for that to be safe, we can only perform one refinement at a time

Definition at line 9245 of file FEProblemBase.C.

Referenced by FEProblemSolve::solve().

{
  // ResetDisplacedMeshThread::onNode looks up the reference mesh by ID, so we need to make sure
  // we undisplace before adapting the reference mesh
  if (_displaced_problem)
    _displaced_problem->undisplaceMesh();

  Adaptivity::uniformRefine(&_mesh, 1);
  if (_displaced_problem)
    Adaptivity::uniformRefine(&_displaced_problem->mesh(), 1);

  meshChanged(
      /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
}

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.

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

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

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

updateActiveObjects()

void FEProblemBase::updateActiveObjects ( )

virtualinherited

Update the active objects in the warehouses.

Reimplemented in DumpObjectsProblem.

Definition at line 5301 of file FEProblemBase.C.

Referenced by MooseEigenSystem::eigenKernelOnCurrent(), MooseEigenSystem::eigenKernelOnOld(), MFEMProblemSolve::solve(), and FixedPointSolve::solveStep().

{
  TIME_SECTION("updateActiveObjects", 5, "Updating Active Objects");

  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
  {
    for (auto & nl : _nl)
      nl->updateActive(tid);
    _aux->updateActive(tid);
    _indicators.updateActive(tid);
    _internal_side_indicators.updateActive(tid);
    _markers.updateActive(tid);
    _all_materials.updateActive(tid);
    _materials.updateActive(tid);
    _discrete_materials.updateActive(tid);
  }

  _control_warehouse.updateActive();
  _multi_apps.updateActive();
  _transient_multi_apps.updateActive();
  _transfers.updateActive();
  _to_multi_app_transfers.updateActive();
  _from_multi_app_transfers.updateActive();
  _between_multi_app_transfers.updateActive();

#ifdef MOOSE_KOKKOS_ENABLED
  _kokkos_materials.updateActive();
#endif
}

updateGeomSearch()

void FEProblemBase::updateGeomSearch ( GeometricSearchData::GeometricSearchType  type = GeometricSearchData::ALL )

overridevirtualinherited

Implements SubProblem.

Definition at line 8020 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::augmentSparsity(), and FEProblemBase::initialSetup().

{
  TIME_SECTION("updateGeometricSearch", 3, "Updating Geometric Search");

  _geometric_search_data.update(type);

  if (_displaced_problem)
    _displaced_problem->updateGeomSearch(type);
}

updateMeshXFEM()

bool FEProblemBase::updateMeshXFEM ( )

virtualinherited

Update the mesh due to changing XFEM cuts.

Definition at line 8281 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup(), and FixedPointSolve::solveStep().

{
  TIME_SECTION("updateMeshXFEM", 5, "Updating XFEM");

  bool updated = false;
  if (haveXFEM())
  {
    if (_xfem->updateHeal())
      // XFEM exodiff tests rely on a given numbering because they cannot use map = true due to
      // having coincident elements. While conceptually speaking we do not need to contract the
      // mesh, we need its call to renumber_nodes_and_elements in order to preserve these tests
      meshChanged(
          /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/false);

    updated = _xfem->update(_time, _nl, *_aux);
    if (updated)
    {
      meshChanged(
          /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/false);
      _xfem->initSolution(_nl, *_aux);
      restoreSolutions();
      _console << "\nXFEM update complete: Mesh modified" << std::endl;
    }
    else
      _console << "\nXFEM update complete: Mesh not modified" << std::endl;
  }
  return updated;
}

updateMortarMesh()

void FEProblemBase::updateMortarMesh ( )

virtualinherited

Definition at line 8031 of file FEProblemBase.C.

Referenced by FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::init(), FEProblemBase::initialSetup(), and FEProblemBase::meshChanged().

{
  TIME_SECTION("updateMortarMesh", 5, "Updating Mortar Mesh");

  FloatingPointExceptionGuard fpe_guard(_app);

  _mortar_data->update();
}

updateSolution()

bool FEProblemBase::updateSolution ( NumericVector< libMesh::Number > &  vec_solution, NumericVector< libMesh::Number > &  ghosted_solution  )

virtualinherited

Update the solution.

Parameters

vec_solution	Local solution vector that gets modified by this method
ghosted_solution	Ghosted solution vector

Returns

true if the solution was modified, false otherwise

Definition at line 7999 of file FEProblemBase.C.

Referenced by FEProblemBase::computePostCheck().

{
  return false;
}

useSNESMFReuseBase()

bool FEProblemBase::useSNESMFReuseBase ( )

inlineinherited

Return a flag that indicates if we are reusing the vector base.

Definition at line 2326 of file FEProblemBase.h.

Referenced by NonlinearSystem::potentiallySetupFiniteDifferencing().

{ return _snesmf_reuse_base; }

validParams()

InputParameters MFEMProblem::validParams ( )

static

Definition at line 25 of file MFEMProblem.C.

{
  InputParameters params = ExternalProblem::validParams();
  params.addClassDescription("Problem type for building and solving finite element problem using"
                             " the MFEM finite element library.");
  return params;
}

vectorTagExists() [1/2]

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

inlinevirtualinherited

Check to see if a particular Tag exists.

Reimplemented in DisplacedProblem.

Definition at line 201 of file SubProblem.h.

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

{ return tag_id < _vector_tags.size(); }

vectorTagExists() [2/2]

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

virtualinherited

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

Reimplemented in DisplacedProblem.

Definition at line 137 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

virtualinherited

Retrieve the name associated with a TagID.

Reimplemented in DisplacedProblem.

Definition at line 222 of file SubProblem.C.

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

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

vectorTagNotZeroed()

bool SubProblem::vectorTagNotZeroed ( const TagID  tag ) const

inherited

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 156 of file SubProblem.C.

Referenced by SystemBase::zeroTaggedVector().

{
  return _not_zeroed_tagged_vectors.count(tag);
}

vectorTagType()

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

virtualinherited

Reimplemented in DisplacedProblem.

Definition at line 232 of file SubProblem.C.

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

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

verboseMultiApps()

bool FEProblemBase::verboseMultiApps ( ) const

inlineinherited

Whether or not to use verbose printing for MultiApps.

Definition at line 2040 of file FEProblemBase.h.

Referenced by MultiApp::backup(), MultiApp::createApp(), MultiApp::restore(), FullSolveMultiApp::showStatusMessage(), and TransientMultiApp::solveStep().

{ return _verbose_multiapps; }

verifyVectorTags()

bool SubProblem::verifyVectorTags ( ) const

protectedinherited

Verify the integrity of _vector_tags and _typed_vector_tags.

Definition at line 242 of file SubProblem.C.

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

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

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

protectedinherited

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

Definition at line 1077 of file SubProblem.h.

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

_active_fe_var_coupleable_matrix_tags

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

protectedinherited

Definition at line 1083 of file SubProblem.h.

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

_active_fe_var_coupleable_vector_tags

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

protectedinherited

Definition at line 1085 of file SubProblem.h.

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

_active_sc_var_coupleable_matrix_tags

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

protectedinherited

Definition at line 1087 of file SubProblem.h.

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

_active_sc_var_coupleable_vector_tags

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

protectedinherited

Definition at line 1089 of file SubProblem.h.

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

_ad_grad_zero

std::vector<MooseArray<ADRealVectorValue> > FEProblemBase::_ad_grad_zero

inherited

Definition at line 2258 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_ad_second_zero

std::vector<MooseArray<ADRealTensorValue> > FEProblemBase::_ad_second_zero

inherited

Definition at line 2261 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_ad_zero

std::vector<MooseArray<ADReal> > FEProblemBase::_ad_zero

inherited

Definition at line 2256 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_adaptivity

Adaptivity FEProblemBase::_adaptivity

protectedinherited

Definition at line 3038 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptivity(), FEProblemBase::adaptMesh(), FEProblemBase::addAnyRedistributers(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::computeMarkers(), FEProblemBase::hasInitialAdaptivity(), FEProblemBase::initialAdaptMesh(), and FEProblemBase::initialSetup().

_all_materials

MaterialWarehouse FEProblemBase::_all_materials

protectedinherited

Definition at line 2936 of file FEProblemBase.h.

Referenced by FEProblemBase::addFunctorMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::computeBounds(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::customSetup(), FEProblemBase::getMaterial(), FEProblemBase::getMaterialWarehouse(), FEProblemBase::initialSetup(), FEProblemBase::neighborSubdomainSetup(), FEProblemBase::prepareMaterials(), FEProblemBase::setActiveMaterialProperties(), FEProblemBase::subdomainSetup(), FEProblemBase::timestepSetup(), and FEProblemBase::updateActiveObjects().

_all_user_objects

ExecuteMooseObjectWarehouse<UserObject> FEProblemBase::_all_user_objects

protectedinherited

Definition at line 2956 of file FEProblemBase.h.

Referenced by FEProblemBase::addUserObject(), and FEProblemBase::getUserObjects().

_app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 357 of file MooseBase.h.

_assembly

std::vector<std::vector<std::unique_ptr<Assembly> > > FEProblemBase::_assembly

protectedinherited

The Assembly objects.

The first index corresponds to the thread ID and the second index corresponds to the nonlinear system number

Definition at line 2890 of file FEProblemBase.h.

Referenced by FEProblemBase::addCachedResidualDirectly(), FEProblemBase::addJacobian(), FEProblemBase::addJacobianBlockTags(), FEProblemBase::addJacobianLowerD(), FEProblemBase::addJacobianNeighbor(), FEProblemBase::addJacobianNeighborLowerD(), FEProblemBase::addJacobianOffDiagScalar(), FEProblemBase::addJacobianScalar(), FEProblemBase::addResidual(), FEProblemBase::addResidualLower(), FEProblemBase::addResidualNeighbor(), FEProblemBase::addResidualScalar(), FEProblemBase::assembly(), FEProblemBase::bumpAllQRuleOrder(), FEProblemBase::bumpVolumeQRuleOrder(), FEProblemBase::couplingEntries(), FEProblemBase::createQRules(), FEProblemBase::init(), FEProblemBase::initElementStatefulProps(), FEProblemBase::initialSetup(), FEProblemBase::initXFEM(), FEProblemBase::meshChanged(), FEProblemBase::newAssemblyArray(), FEProblemBase::nonlocalCouplingEntries(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareFaceShapes(), FEProblemBase::prepareNeighborShapes(), FEProblemBase::prepareShapes(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitElemPhys(), FEProblemBase::reinitMaterials(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsInterface(), FEProblemBase::reinitMaterialsNeighbor(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::reinitOffDiagScalars(), FEProblemBase::reinitScalars(), FEProblemBase::setCurrentSubdomainID(), FEProblemBase::setResidual(), FEProblemBase::setResidualNeighbor(), FEProblemBase::swapBackMaterials(), FEProblemBase::swapBackMaterialsFace(), and FEProblemBase::swapBackMaterialsNeighbor().

_aux

std::shared_ptr<AuxiliarySystem> FEProblemBase::_aux

protectedinherited

The auxiliary system.

Definition at line 2876 of file FEProblemBase.h.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addIndicator(), FEProblemBase::addMarker(), FEProblemBase::addMultiApp(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::advanceState(), FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::computeBounds(), FEProblemBase::computeIndicators(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeMarkers(), FEProblemBase::computePostCheck(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::computeSystems(), FEProblemBase::computeUserObjectsInternal(), FEProblemBase::copySolutionsBackwards(), FEProblemBase::createQRules(), FEProblemBase::createTagMatrices(), FEProblemBase::createTagSolutions(), FEProblemBase::customSetup(), FEProblemBase::determineSolverSystem(), DumpObjectsProblem::DumpObjectsProblem(), FEProblemBase::duplicateVariableCheck(), EigenProblem::EigenProblem(), FEProblemBase::execute(), ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), FEProblemBase::getActualFieldVariable(), FEProblemBase::getArrayVariable(), FEProblemBase::getAuxiliarySystem(), FEProblemBase::getScalarVariable(), FEProblemBase::getStandardVariable(), FEProblemBase::getSystem(), FEProblemBase::getSystemBase(), FEProblemBase::getVariable(), FEProblemBase::getVariableNames(), FEProblemBase::getVectorVariable(), FEProblemBase::hasScalarVariable(), FEProblemBase::hasVariable(), FEProblemBase::init(), FEProblemBase::initialSetup(), FEProblemBase::meshChanged(), FEProblemBase::needBoundaryMaterialOnSide(), FEProblemBase::needSolutionState(), FEProblemBase::outputStep(), FEProblemBase::prepareFace(), FEProblemBase::projectInitialConditionOnCustomRange(), FEProblemBase::projectSolution(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElem(), FEProblemBase::reinitElemPhys(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::reinitNodes(), FEProblemBase::reinitNodesNeighbor(), FEProblemBase::reinitScalars(), FEProblemBase::restoreOldSolutions(), FEProblemBase::restoreSolutions(), FEProblemBase::saveOldSolutions(), FEProblemBase::setAuxKernelParamsAndLog(), FEProblemBase::systemBaseAuxiliary(), FEProblemBase::systemNumForVariable(), FEProblemBase::timestepSetup(), FEProblemBase::updateActiveObjects(), and FEProblemBase::updateMeshXFEM().

_aux_evaluable_local_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_aux_evaluable_local_elem_range

protectedinherited

Definition at line 3173 of file FEProblemBase.h.

_between_multi_app_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_between_multi_app_transfers

protectedinherited

Transfers executed just before MultiApps to transfer data between them.

Definition at line 2974 of file FEProblemBase.h.

Referenced by FEProblemBase::addTransfer(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::getMultiAppTransferWarehouse(), FEProblemBase::getTransfers(), FEProblemBase::initialSetup(), and FEProblemBase::updateActiveObjects().

_block_mat_side_cache

std::vector<std::unordered_map<SubdomainID, bool> > FEProblemBase::_block_mat_side_cache

protectedinherited

Cache for calculating materials on side.

Definition at line 2980 of file FEProblemBase.h.

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

_bnd_mat_side_cache

std::vector<std::unordered_map<BoundaryID, bool> > FEProblemBase::_bnd_mat_side_cache

protectedinherited

Cache for calculating materials on side.

Definition at line 2983 of file FEProblemBase.h.

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

_bnd_material_props

MaterialPropertyStorage& FEProblemBase::_bnd_material_props

protectedinherited

Definition at line 2923 of file FEProblemBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), FEProblemBase::advanceState(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::getBndMaterialPropertyStorage(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), FEProblemBase::initElementStatefulProps(), FEProblemBase::initialSetup(), FEProblemBase::initXFEM(), FEProblemBase::meshChanged(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsInterface(), and FEProblemBase::swapBackMaterialsFace().

_boundary_restricted_elem_integrity_check

const bool FEProblemBase::_boundary_restricted_elem_integrity_check

protectedinherited

whether to perform checking of boundary restricted elemental object variable dependencies, e.g.

whether the variable dependencies are defined on the selected boundaries

Definition at line 3112 of file FEProblemBase.h.

Referenced by FEProblemBase::initialSetup().

_boundary_restricted_node_integrity_check

const bool FEProblemBase::_boundary_restricted_node_integrity_check

protectedinherited

whether to perform checking of boundary restricted nodal object variable dependencies, e.g.

whether the variable dependencies are defined on the selected boundaries

Definition at line 3108 of file FEProblemBase.h.

Referenced by FEProblemBase::initialSetup().

_calculate_jacobian_in_uo

bool FEProblemBase::_calculate_jacobian_in_uo

protectedinherited

Definition at line 3093 of file FEProblemBase.h.

Referenced by FEProblemBase::checkNonlocalCoupling(), FEProblemBase::checkUserObjectJacobianRequirement(), and FEProblemBase::meshChanged().

_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().

_cm

std::vector<std::unique_ptr<libMesh::CouplingMatrix> > FEProblemBase::_cm

protectedinherited

Coupling matrix for variables.

Definition at line 2879 of file FEProblemBase.h.

Referenced by FEProblemBase::areCoupled(), FEProblemBase::couplingMatrix(), FEProblemBase::FEProblemBase(), FEProblemBase::init(), and FEProblemBase::setCouplingMatrix().

_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

protectedinherited

Whether the non-linear residual is being evaluated.

Definition at line 1104 of file SubProblem.h.

Referenced by SubProblem::computingNonlinearResid(), and FEProblemBase::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(), MeshOnlyAction::act(), SetupDebugAction::act(), MaterialOutputAction::act(), Adaptivity::adaptMesh(), FEProblemBase::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::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkNonPlanarSides(), FEProblemBase::checkProblemIntegrity(), ReferenceResidualConvergence::checkRelativeConvergence(), MeshDiagnosticsGenerator::checkSidesetsOrientation(), MeshDiagnosticsGenerator::checkWatertightNodesets(), MeshDiagnosticsGenerator::checkWatertightSidesets(), IterationAdaptiveDT::computeAdaptiveDT(), TransientBase::computeConstrainedDT(), DefaultMultiAppFixedPointConvergence::computeCustomConvergencePostprocessor(), NonlinearSystemBase::computeDamping(), FixedPointIterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeDT(), IterationAdaptiveDT::computeFailedDT(), IterationAdaptiveDT::computeInitialDT(), IterationAdaptiveDT::computeInterpolationDT(), LinearSystem::computeLinearSystemTags(), FEProblemBase::computeLinearSystemTags(), NonlinearSystemBase::computeScaling(), Problem::console(), IterationAdaptiveDT::constrainStep(), TimeStepper::constrainStep(), MultiApp::createApp(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), MFEMSteady::execute(), MessageFromInput::execute(), SteadyBase::execute(), Eigenvalue::execute(), ActionWarehouse::executeActionsWithAction(), ActionWarehouse::executeAllActions(), MeshGeneratorSystem::executeMeshGenerators(), ElementQualityChecker::finalize(), SidesetAroundSubdomainUpdater::finalize(), FEProblemBase::finishMultiAppStep(), MeshRepairGenerator::fixOverlappingNodes(), CoarsenBlockGenerator::generate(), MeshGenerator::generateInternal(), VariableCondensationPreconditioner::getDofToCondense(), NonlinearEigen::init(), InversePowerMethod::init(), FEProblemBase::initialAdaptMesh(), DefaultMultiAppFixedPointConvergence::initialize(), SubProblem::initialSetup(), EigenExecutionerBase::inversePowerIteration(), FEProblemBase::joinAndFinalize(), TransientBase::keepGoing(), IterationAdaptiveDT::limitDTByFunction(), IterationAdaptiveDT::limitDTToPostprocessorValue(), FEProblemBase::logAdd(), EigenExecutionerBase::makeBXConsistent(), Console::meshChanged(), MooseBase::mooseDeprecated(), MooseBase::mooseInfo(), MooseBase::mooseWarning(), MooseBase::mooseWarningNonPrefixed(), ReferenceResidualConvergence::nonlinearConvergenceSetup(), ReporterDebugOutput::output(), PerfGraphOutput::output(), SolutionInvalidityOutput::output(), MaterialPropertyDebugOutput::output(), DOFMapOutput::output(), VariableResidualNormsDebugOutput::output(), Console::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Console::outputInput(), Console::outputPostprocessors(), PseudoTimestep::outputPseudoTimestep(), Console::outputReporters(), DefaultMultiAppFixedPointConvergence::outputResidualNorm(), Console::outputScalarVariables(), Console::outputSystemInformation(), FEProblemBase::possiblyRebuildGeomSearchPatches(), EigenExecutionerBase::postExecute(), AB2PredictorCorrector::postSolve(), ActionWarehouse::printActionDependencySets(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), SolutionInvalidity::printDebug(), EigenExecutionerBase::printEigenvalue(), SecantSolve::printFixedPointConvergenceHistory(), SteffensenSolve::printFixedPointConvergenceHistory(), PicardSolve::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(), SubProblem::showFunctorRequestors(), SubProblem::showFunctors(), FullSolveMultiApp::showStatusMessage(), EigenProblem::solve(), FEProblemSolve::solve(), FixedPointSolve::solve(), NonlinearSystem::solve(), LinearSystem::solve(), LStableDirk2::solve(), LStableDirk3::solve(), ImplicitMidpoint::solve(), ExplicitTVDRK2::solve(), LStableDirk4::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), FixedPointSolve::solveStep(), PerfGraphLivePrint::start(), AB2PredictorCorrector::step(), NonlinearEigen::takeStep(), MFEMTransient::takeStep(), TransientBase::takeStep(), TerminateChainControl::terminate(), SubProblem::timestepSetup(), FEProblemBase::updateMeshXFEM(), Convergence::verboseOutput(), Console::writeTimestepInformation(), Console::writeVariableNorms(), and FEProblemBase::~FEProblemBase().

_const_jacobian

bool FEProblemBase::_const_jacobian

protectedinherited

true if the Jacobian is constant

Definition at line 3080 of file FEProblemBase.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::constJacobian(), and FEProblemBase::setConstJacobian().

_control_warehouse

ExecuteMooseObjectWarehouse<Control> FEProblemBase::_control_warehouse

protectedinherited

The control logic warehouse.

Definition at line 3158 of file FEProblemBase.h.

Referenced by FEProblemBase::executeControls(), FEProblemBase::getControlWarehouse(), and FEProblemBase::updateActiveObjects().

_convergences

MooseObjectWarehouse<Convergence> FEProblemBase::_convergences

protectedinherited

convergence warehouse

Definition at line 2905 of file FEProblemBase.h.

Referenced by FEProblemBase::addConvergence(), FEProblemBase::getConvergence(), FEProblemBase::getConvergenceObjects(), FEProblemBase::hasConvergence(), and FEProblemBase::initialSetup().

_coupling

Moose::CouplingType FEProblemBase::_coupling

protectedinherited

Type of variable coupling.

Definition at line 2878 of file FEProblemBase.h.

Referenced by FEProblemBase::coupling(), FEProblemBase::init(), FEProblemBase::setCoupling(), and FEProblemBase::trustUserCouplingMatrix().

_current_algebraic_bnd_node_range

std::unique_ptr<ConstBndNodeRange> FEProblemBase::_current_algebraic_bnd_node_range

protectedinherited

Definition at line 3177 of file FEProblemBase.h.

Referenced by FEProblemBase::getCurrentAlgebraicBndNodeRange(), and FEProblemBase::setCurrentAlgebraicBndNodeRange().

_current_algebraic_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_current_algebraic_elem_range

protectedinherited

Definition at line 3175 of file FEProblemBase.h.

Referenced by FEProblemBase::getCurrentAlgebraicElementRange(), and FEProblemBase::setCurrentAlgebraicElementRange().

_current_algebraic_node_range

std::unique_ptr<libMesh::ConstNodeRange> FEProblemBase::_current_algebraic_node_range

protectedinherited

Definition at line 3176 of file FEProblemBase.h.

Referenced by FEProblemBase::getCurrentAlgebraicNodeRange(), and FEProblemBase::setCurrentAlgebraicNodeRange().

_current_execute_on_flag

ExecFlagType FEProblemBase::_current_execute_on_flag

protectedinherited

Current execute_on flag.

Definition at line 3155 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computePostCheck(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::computeUserObjectByName(), FEProblemBase::getCurrentExecuteOnFlag(), FEProblemBase::joinAndFinalize(), FEProblemBase::resetState(), FEProblemBase::setCurrentExecuteOnFlag(), and FEProblemBase::shouldPrintExecution().

_current_ic_state

unsigned short FEProblemBase::_current_ic_state

protectedinherited

Definition at line 3184 of file FEProblemBase.h.

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

_current_linear_sys

LinearSystem* FEProblemBase::_current_linear_sys

protectedinherited

The current linear system that we are solving.

Definition at line 2840 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::computeLinearSystemSys(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualL2Norm(), FEProblemBase::currentLinearSystem(), FEProblemBase::setCurrentLinearSystem(), and FEProblemBase::solveLinearSystem().

_current_nl_sys

NonlinearSystemBase* FEProblemBase::_current_nl_sys

protectedinherited

The current nonlinear system that we are solving.

Definition at line 2858 of file FEProblemBase.h.

Referenced by FEProblemBase::addCachedResidualDirectly(), FEProblemBase::addJacobian(), FEProblemBase::addJacobianBlockTags(), FEProblemBase::addJacobianLowerD(), FEProblemBase::addJacobianNeighbor(), FEProblemBase::addJacobianNeighborLowerD(), FEProblemBase::addJacobianOffDiagScalar(), FEProblemBase::addJacobianScalar(), FEProblemBase::addResidual(), FEProblemBase::addResidualLower(), FEProblemBase::addResidualNeighbor(), FEProblemBase::addResidualScalar(), FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::computeBounds(), FEProblemBase::computeDamping(), FEProblemBase::computeJacobianBlock(), EigenProblem::computeJacobianBlocks(), FEProblemBase::computeJacobianBlocks(), FEProblemBase::computeJacobianInternal(), FEProblemBase::computeJacobianTag(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeNearNullSpace(), FEProblemBase::computeNullSpace(), FEProblemBase::computePostCheck(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualL2Norm(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualTags(), FEProblemBase::computeResidualType(), FEProblemBase::computeTransposeNullSpace(), FEProblemBase::currentNonlinearSystem(), EigenProblem::doFreeNonlinearPowerIterations(), EigenProblem::EigenProblem(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareFaceShapes(), FEProblemBase::prepareNeighborShapes(), FEProblemBase::prepareShapes(), FEProblemBase::reinitDirac(), FEProblemBase::reinitOffDiagScalars(), FEProblemBase::setCurrentNonlinearSystem(), FEProblemBase::setResidual(), FEProblemBase::setResidualNeighbor(), EigenProblem::solve(), and FEProblemBase::solve().

_current_solver_sys

SolverSystem* FEProblemBase::_current_solver_sys

protectedinherited

The current solver system.

Definition at line 2861 of file FEProblemBase.h.

Referenced by FEProblemBase::setCurrentLinearSystem(), and FEProblemBase::setCurrentNonlinearSystem().

_currently_computing_jacobian

bool SubProblem::_currently_computing_jacobian

protectedinherited

Flag to determine whether the problem is currently computing Jacobian.

Definition at line 1098 of file SubProblem.h.

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

_currently_computing_residual

bool SubProblem::_currently_computing_residual

protectedinherited

Whether the residual is being evaluated.

Definition at line 1107 of file SubProblem.h.

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

_currently_computing_residual_and_jacobian

bool SubProblem::_currently_computing_residual_and_jacobian

protectedinherited

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

Definition at line 1101 of file SubProblem.h.

Referenced by SubProblem::currentlyComputingResidualAndJacobian(), and SubProblem::setCurrentlyComputingResidualAndJacobian().

_cycles_completed

unsigned int FEProblemBase::_cycles_completed

protectedinherited

Definition at line 3039 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::getNumCyclesCompleted(), and FEProblemBase::initialAdaptMesh().

_default_ghosting

bool SubProblem::_default_ghosting

protectedinherited

Whether or not to use default libMesh coupling.

Definition at line 1092 of file SubProblem.h.

Referenced by SubProblem::defaultGhosting().

_dirac_kernel_info

DiracKernelInfo SubProblem::_dirac_kernel_info

protectedinherited

Definition at line 1051 of file SubProblem.h.

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

_discrete_materials

MaterialWarehouse FEProblemBase::_discrete_materials

protectedinherited

Definition at line 2935 of file FEProblemBase.h.

Referenced by FEProblemBase::addMaterialHelper(), FEProblemBase::getDiscreteMaterialWarehouse(), FEProblemBase::initialSetup(), FEProblemBase::reinitMaterials(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsNeighbor(), and FEProblemBase::updateActiveObjects().

_displaced_mesh

MooseMesh* FEProblemBase::_displaced_mesh

protectedinherited

Definition at line 3046 of file FEProblemBase.h.

Referenced by FEProblemBase::addDisplacedProblem(), FEProblemBase::addGhostedBoundary(), FEProblemBase::checkDisplacementOrders(), FEProblemBase::ghostGhostedBoundaries(), FEProblemBase::init(), FEProblemBase::initialSetup(), FEProblemBase::initXFEM(), FEProblemBase::meshChanged(), FEProblemBase::possiblyRebuildGeomSearchPatches(), FEProblemBase::prepareFace(), FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElem(), FEProblemBase::reinitElemFaceRef(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitLowerDElem(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNeighborFaceRef(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::setCurrentLowerDElem(), and FEProblemBase::timestepSetup().

_displaced_problem

std::shared_ptr<DisplacedProblem> FEProblemBase::_displaced_problem

protectedinherited

Definition at line 3047 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarKernel(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addCachedJacobian(), FEProblemBase::addCachedResidual(), FEProblemBase::addCachedResidualDirectly(), FEProblemBase::addConstraint(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDisplacedProblem(), FEProblemBase::addFunction(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVKernel(), FEProblemBase::addGhostedBoundary(), FEProblemBase::addIndicator(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addJacobian(), FEProblemBase::addJacobianBlockTags(), FEProblemBase::addJacobianLowerD(), FEProblemBase::addJacobianNeighbor(), FEProblemBase::addJacobianNeighborLowerD(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addResidual(), FEProblemBase::addResidualLower(), FEProblemBase::addResidualNeighbor(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), FEProblemBase::addVariable(), FEProblemBase::advanceState(), FEProblemBase::automaticScaling(), FEProblemBase::bumpAllQRuleOrder(), FEProblemBase::bumpVolumeQRuleOrder(), FEProblemBase::cacheJacobian(), FEProblemBase::cacheJacobianNeighbor(), FEProblemBase::cacheResidual(), FEProblemBase::cacheResidualNeighbor(), FEProblemBase::checkDisplacementOrders(), FEProblemBase::clearActiveElementalMooseVariables(), FEProblemBase::clearActiveFEVariableCoupleableMatrixTags(), FEProblemBase::clearActiveFEVariableCoupleableVectorTags(), FEProblemBase::clearActiveScalarVariableCoupleableMatrixTags(), FEProblemBase::clearActiveScalarVariableCoupleableVectorTags(), FEProblemBase::clearDiracInfo(), EigenProblem::computeJacobianBlocks(), FEProblemBase::computeJacobianBlocks(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::computeUserObjectsInternal(), FEProblemBase::computingNonlinearResid(), FEProblemBase::createMortarInterface(), FEProblemBase::createQRules(), FEProblemBase::customSetup(), FEProblemBase::execute(), FEProblemBase::getDiracElements(), FEProblemBase::getDisplacedProblem(), FEProblemBase::getMortarUserObjects(), FEProblemBase::ghostGhostedBoundaries(), FEProblemBase::haveADObjects(), FEProblemBase::haveDisplaced(), FEProblemBase::init(), FEProblemBase::initialSetup(), FEProblemBase::initXFEM(), FEProblemBase::jacobianSetup(), FEProblemBase::mesh(), FEProblemBase::meshChanged(), FEProblemBase::outputStep(), FEProblemBase::possiblyRebuildGeomSearchPatches(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareFace(), FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElem(), FEProblemBase::reinitElemFaceRef(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitLowerDElem(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNeighborFaceRef(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::reinitNodes(), FEProblemBase::reinitNodesNeighbor(), FEProblemBase::reinitOffDiagScalars(), FEProblemBase::reinitScalars(), FEProblemBase::resetState(), FEProblemBase::residualSetup(), FEProblemBase::restoreSolutions(), FEProblemBase::setActiveElementalMooseVariables(), FEProblemBase::setActiveFEVariableCoupleableMatrixTags(), FEProblemBase::setActiveFEVariableCoupleableVectorTags(), FEProblemBase::setActiveScalarVariableCoupleableMatrixTags(), FEProblemBase::setActiveScalarVariableCoupleableVectorTags(), FEProblemBase::setAuxKernelParamsAndLog(), FEProblemBase::setCurrentBoundaryID(), FEProblemBase::setCurrentLowerDElem(), FEProblemBase::setCurrentlyComputingResidual(), FEProblemBase::setCurrentSubdomainID(), FEProblemBase::setResidual(), FEProblemBase::setResidualNeighbor(), FEProblemBase::setResidualObjectParamsAndLog(), EigenProblem::solve(), FEProblemBase::solve(), FEProblemBase::timestepSetup(), FEProblemBase::uniformRefine(), and FEProblemBase::updateGeomSearch().

_dt

Real& FEProblemBase::_dt

protectedinherited

Definition at line 2817 of file FEProblemBase.h.

Referenced by FEProblemBase::dt(), FEProblemBase::execMultiApps(), and FEProblemBase::FEProblemBase().

_dt_old

Real& FEProblemBase::_dt_old

protectedinherited

Definition at line 2818 of file FEProblemBase.h.

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

_enabled

const bool& MooseObject::_enabled

protectedinherited

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

Definition at line 86 of file MooseObject.h.

Referenced by MooseObject::enabled().

_evaluable_local_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_evaluable_local_elem_range

protectedinherited

Definition at line 3171 of file FEProblemBase.h.

Referenced by FEProblemBase::getEvaluableElementRange(), and FEProblemBase::meshChanged().

_exception_message

std::string FEProblemBase::_exception_message

protectedinherited

The error message to go with an exception.

Definition at line 3152 of file FEProblemBase.h.

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

_factory

Factory& SubProblem::_factory

protectedinherited

The Factory for building objects.

Definition at line 1049 of file SubProblem.h.

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

_fe_matrix_tags

std::set<TagID> FEProblemBase::_fe_matrix_tags

protectedinherited

Definition at line 2802 of file FEProblemBase.h.

Referenced by FEProblemBase::computeJacobian(), EigenProblem::computeJacobianAB(), EigenProblem::computeJacobianTag(), EigenProblem::computeMatricesTags(), and FEProblemBase::computeResidualAndJacobian().

_fe_vector_tags

std::set<TagID> FEProblemBase::_fe_vector_tags

protectedinherited

Definition at line 2800 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), EigenProblem::computeResidualAB(), FEProblemBase::computeResidualAndJacobian(), and EigenProblem::computeResidualTag().

_from_multi_app_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_from_multi_app_transfers

protectedinherited

Transfers executed just after MultiApps to transfer data from them.

Definition at line 2971 of file FEProblemBase.h.

Referenced by FEProblemBase::addTransfer(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::getMultiAppTransferWarehouse(), FEProblemBase::getTransfers(), FEProblemBase::initialSetup(), and FEProblemBase::updateActiveObjects().

_functions

MooseObjectWarehouse<Function> FEProblemBase::_functions

protectedinherited

functions

Definition at line 2902 of file FEProblemBase.h.

Referenced by FEProblemBase::addFunction(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::customSetup(), FEProblemBase::getFunction(), FEProblemBase::hasFunction(), DumpObjectsProblem::initialSetup(), FEProblemBase::initialSetup(), and FEProblemBase::timestepSetup().

_fv_bcs_integrity_check

bool FEProblemBase::_fv_bcs_integrity_check

protectedinherited

Whether to check overlapping Dirichlet and Flux BCs and/or multiple DirichletBCs per sideset.

Definition at line 3119 of file FEProblemBase.h.

Referenced by FEProblemBase::fvBCsIntegrityCheck().

_fv_ics

FVInitialConditionWarehouse FEProblemBase::_fv_ics

protectedinherited

Definition at line 2916 of file FEProblemBase.h.

Referenced by FEProblemBase::addFVInitialCondition(), FEProblemBase::getFVInitialConditionWarehouse(), and FEProblemBase::initialSetup().

_geometric_search_data

GeometricSearchData FEProblemBase::_geometric_search_data

protectedinherited

Definition at line 3048 of file FEProblemBase.h.

Referenced by FEProblemBase::geomSearchData(), FEProblemBase::meshChanged(), FEProblemBase::possiblyRebuildGeomSearchPatches(), FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects(), and FEProblemBase::updateGeomSearch().

_ghosted_elems

std::set<dof_id_type> SubProblem::_ghosted_elems

protectedinherited

Elements that should have Dofs ghosted to the local processor.

Definition at line 1095 of file SubProblem.h.

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

_grad_phi_zero

std::vector<VariablePhiGradient> FEProblemBase::_grad_phi_zero

inherited

Definition at line 2259 of file FEProblemBase.h.

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

_grad_zero

std::vector<VariableGradient> FEProblemBase::_grad_zero

inherited

Definition at line 2257 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::reinitDirac(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_has_active_elemental_moose_variables

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

protectedinherited

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

Definition at line 1081 of file SubProblem.h.

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

_has_active_material_properties

std::vector<unsigned char> FEProblemBase::_has_active_material_properties

protectedinherited

Whether there are active material properties on each thread.

Definition at line 3098 of file FEProblemBase.h.

Referenced by FEProblemBase::clearActiveMaterialProperties(), FEProblemBase::FEProblemBase(), FEProblemBase::hasActiveMaterialProperties(), and FEProblemBase::setActiveMaterialProperties().

_has_constraints

bool FEProblemBase::_has_constraints

protectedinherited

Whether or not this system has any Constraints.

Definition at line 3065 of file FEProblemBase.h.

Referenced by FEProblemBase::addConstraint(), NonlinearSystemBase::computeJacobianInternal(), and NonlinearSystemBase::computeResidualInternal().

_has_dampers

bool FEProblemBase::_has_dampers

protectedinherited

Whether or not this system has any Dampers associated with it.

Definition at line 3062 of file FEProblemBase.h.

Referenced by FEProblemBase::addDamper(), FEProblemBase::computeDamping(), FEProblemBase::computePostCheck(), and FEProblemBase::hasDampers().

_has_exception

bool FEProblemBase::_has_exception

protectedinherited

Whether or not an exception has occurred.

Definition at line 3137 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::hasException(), and FEProblemBase::setException().

_has_initialized_stateful

bool FEProblemBase::_has_initialized_stateful

protectedinherited

Whether nor not stateful materials have been initialized.

Definition at line 3077 of file FEProblemBase.h.

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

_has_jacobian

bool FEProblemBase::_has_jacobian

protectedinherited

Indicates if the Jacobian was computed.

Definition at line 3083 of file FEProblemBase.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::hasJacobian(), and FEProblemBase::meshChanged().

_has_nonlocal_coupling

bool FEProblemBase::_has_nonlocal_coupling

protectedinherited

Indicates if nonlocal coupling is required/exists.

Definition at line 3092 of file FEProblemBase.h.

Referenced by FEProblemBase::addJacobian(), FEProblemBase::addJacobianBlockTags(), FEProblemBase::hasNonlocalCoupling(), FEProblemBase::prepareAssembly(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElemPhys(), and FEProblemBase::timestepSetup().

_has_time_integrator

bool FEProblemBase::_has_time_integrator

protectedinherited

Indicates whether or not this executioner has a time integrator (during setup)

Definition at line 3134 of file FEProblemBase.h.

Referenced by FEProblemBase::addTimeIntegrator(), and FEProblemBase::hasTimeIntegrator().

_have_ad_objects

bool SubProblem::_have_ad_objects

protectedinherited

AD flag indicating whether any AD objects have been added.

Definition at line 1116 of file SubProblem.h.

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

_ics

InitialConditionWarehouse FEProblemBase::_ics

protectedinherited

Initial condition storage

Definition at line 2915 of file FEProblemBase.h.

Referenced by FEProblemBase::addInitialCondition(), FEProblemBase::getInitialConditionWarehouse(), and FEProblemBase::initialSetup().

_indicators

MooseObjectWarehouse<Indicator> FEProblemBase::_indicators

protectedinherited

Definition at line 2945 of file FEProblemBase.h.

Referenced by FEProblemBase::addIndicator(), FEProblemBase::computeIndicators(), FEProblemBase::customSetup(), FEProblemBase::initialSetup(), FEProblemBase::timestepSetup(), and FEProblemBase::updateActiveObjects().

_initialized

bool FEProblemBase::_initialized

protectedinherited

Definition at line 2789 of file FEProblemBase.h.

Referenced by FEProblemBase::init().

_input_file_saved

bool FEProblemBase::_input_file_saved

protectedinherited

whether input file has been written

Definition at line 3059 of file FEProblemBase.h.

_interface_mat_side_cache

std::vector<std::unordered_map<BoundaryID, bool> > FEProblemBase::_interface_mat_side_cache

protectedinherited

Cache for calculating materials on interface.

Definition at line 2986 of file FEProblemBase.h.

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

_interface_materials

MaterialWarehouse FEProblemBase::_interface_materials

protectedinherited

Definition at line 2934 of file FEProblemBase.h.

Referenced by FEProblemBase::addInterfaceMaterial(), FEProblemBase::getInterfaceMaterialsWarehouse(), FEProblemBase::initialSetup(), FEProblemBase::needInterfaceMaterialOnSide(), and FEProblemBase::reinitMaterialsInterface().

_internal_side_indicators

MooseObjectWarehouse<InternalSideIndicatorBase> FEProblemBase::_internal_side_indicators

protectedinherited

Definition at line 2946 of file FEProblemBase.h.

Referenced by FEProblemBase::addIndicator(), FEProblemBase::computeIndicators(), FEProblemBase::customSetup(), FEProblemBase::getInternalSideIndicatorWarehouse(), FEProblemBase::initialSetup(), FEProblemBase::timestepSetup(), and FEProblemBase::updateActiveObjects().

_is_petsc_options_inserted

bool FEProblemBase::_is_petsc_options_inserted

protectedinherited

If or not PETSc options have been added to database.

Definition at line 3167 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::petscOptionsInserted(), FEProblemBase::solve(), and FEProblemBase::solveLinearSystem().

_kernel_coverage_blocks

std::vector<SubdomainName> FEProblemBase::_kernel_coverage_blocks

protectedinherited

Definition at line 3104 of file FEProblemBase.h.

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

_kernel_coverage_check

CoverageCheckMode FEProblemBase::_kernel_coverage_check

protectedinherited

Determines whether and which subdomains are to be checked to ensure that they have an active kernel.

Definition at line 3103 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity(), FEProblemBase::FEProblemBase(), and FEProblemBase::setKernelCoverageCheck().

_kokkos_assembly

Moose::Kokkos::Assembly FEProblemBase::_kokkos_assembly

protectedinherited

Definition at line 2893 of file FEProblemBase.h.

Referenced by FEProblemBase::kokkosAssembly().

_kokkos_bnd_material_props

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::_kokkos_bnd_material_props

protectedinherited

Definition at line 2928 of file FEProblemBase.h.

Referenced by FEProblemBase::advanceState(), FEProblemBase::getKokkosBndMaterialPropertyStorage(), and FEProblemBase::initialSetup().

_kokkos_material_props

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::_kokkos_material_props

protectedinherited

Definition at line 2927 of file FEProblemBase.h.

Referenced by FEProblemBase::advanceState(), FEProblemBase::getKokkosMaterialPropertyStorage(), and FEProblemBase::initialSetup().

_kokkos_materials

MaterialWarehouse FEProblemBase::_kokkos_materials

protectedinherited

Definition at line 2939 of file FEProblemBase.h.

Referenced by FEProblemBase::getKokkosMaterialsWarehouse(), FEProblemBase::initialSetup(), and FEProblemBase::updateActiveObjects().

_kokkos_neighbor_material_props

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::_kokkos_neighbor_material_props

protectedinherited

Definition at line 2929 of file FEProblemBase.h.

Referenced by FEProblemBase::advanceState(), FEProblemBase::getKokkosNeighborMaterialPropertyStorage(), and FEProblemBase::initialSetup().

_kokkos_systems

Moose::Kokkos::Array<Moose::Kokkos::System> FEProblemBase::_kokkos_systems

protectedinherited

Definition at line 2882 of file FEProblemBase.h.

Referenced by FEProblemBase::getKokkosSystems().

_line_search

std::shared_ptr<LineSearch> FEProblemBase::_line_search

protectedinherited

Definition at line 3169 of file FEProblemBase.h.

Referenced by FEProblem::addLineSearch(), FEProblemBase::customSetup(), FEProblemBase::getLineSearch(), FEProblemBase::initialSetup(), FEProblemBase::lineSearch(), and FEProblemBase::timestepSetup().

_linear_convergence_names

std::optional<std::vector<ConvergenceName> > FEProblemBase::_linear_convergence_names

protectedinherited

Linear system(s) convergence name(s) (if any)

Definition at line 2794 of file FEProblemBase.h.

Referenced by FEProblemBase::getLinearConvergenceNames(), FEProblemBase::hasLinearConvergenceObjects(), and FEProblemBase::setLinearConvergenceNames().

_linear_matrix_tags

std::set<TagID> FEProblemBase::_linear_matrix_tags

protectedinherited

Temporary storage for filtered matrix tags for linear systems.

Definition at line 2808 of file FEProblemBase.h.

Referenced by FEProblemBase::computeLinearSystemSys().

_linear_sys_name_to_num

std::map<LinearSystemName, unsigned int> FEProblemBase::_linear_sys_name_to_num

protectedinherited

Map from linear system name to number.

Definition at line 2837 of file FEProblemBase.h.

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

_linear_sys_names

const std::vector<LinearSystemName> FEProblemBase::_linear_sys_names

protectedinherited

The linear system names.

Definition at line 2828 of file FEProblemBase.h.

Referenced by DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), FEProblem::FEProblem(), FEProblemBase::FEProblemBase(), and FEProblemBase::getLinearSystemNames().

_linear_systems

std::vector<std::shared_ptr<LinearSystem> > FEProblemBase::_linear_systems

protectedinherited

The vector of linear systems.

Definition at line 2834 of file FEProblemBase.h.

Referenced by FEProblemBase::computeResidualL2Norm(), FEProblemBase::currentLinearSysNum(), DumpObjectsProblem::DumpObjectsProblem(), FEProblem::FEProblem(), FEProblemBase::getLinearSystem(), FEProblemBase::setCurrentLinearSystem(), and FEProblemBase::systemBaseLinear().

_linear_vector_tags

std::set<TagID> FEProblemBase::_linear_vector_tags

protectedinherited

Temporary storage for filtered vector tags for linear systems.

Definition at line 2805 of file FEProblemBase.h.

Referenced by FEProblemBase::computeLinearSystemSys().

_map_block_material_props

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

protectedinherited

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

Definition at line 1054 of file SubProblem.h.

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

_map_block_material_props_check

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

protectedinherited

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 1072 of file SubProblem.h.

Referenced by SubProblem::checkBlockMatProps(), and SubProblem::storeSubdomainDelayedCheckMatProp().

_map_boundary_material_props

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

protectedinherited

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

Definition at line 1057 of file SubProblem.h.

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

_map_boundary_material_props_check

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

protectedinherited

Definition at line 1073 of file SubProblem.h.

Referenced by SubProblem::checkBoundaryMatProps(), and SubProblem::storeBoundaryDelayedCheckMatProp().

_markers

MooseObjectWarehouse<Marker> FEProblemBase::_markers

protectedinherited

Definition at line 2950 of file FEProblemBase.h.

Referenced by FEProblemBase::addMarker(), FEProblemBase::computeMarkers(), FEProblemBase::customSetup(), FEProblemBase::getMarkerWarehouse(), FEProblemBase::initialSetup(), FEProblemBase::timestepSetup(), and FEProblemBase::updateActiveObjects().

_material_coverage_blocks

std::vector<SubdomainName> FEProblemBase::_material_coverage_blocks

protectedinherited

Definition at line 3116 of file FEProblemBase.h.

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

_material_coverage_check

CoverageCheckMode FEProblemBase::_material_coverage_check

protectedinherited

Determines whether and which subdomains are to be checked to ensure that they have an active material.

Definition at line 3115 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity(), FEProblemBase::FEProblemBase(), and FEProblemBase::setMaterialCoverageCheck().

_material_dependency_check

const bool FEProblemBase::_material_dependency_check

protectedinherited

Determines whether a check to verify material dependencies on every subdomain.

Definition at line 3122 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity().

_material_prop_registry

MaterialPropertyRegistry FEProblemBase::_material_prop_registry

protectedinherited

Definition at line 2921 of file FEProblemBase.h.

Referenced by FEProblemBase::checkDependMaterialsHelper(), and FEProblemBase::getMaterialPropertyRegistry().

_material_property_requested

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

protectedinherited

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

Definition at line 1064 of file SubProblem.h.

Referenced by SubProblem::isMatPropRequested(), and SubProblem::markMatPropRequested().

_material_props

MaterialPropertyStorage& FEProblemBase::_material_props

protectedinherited

Definition at line 2922 of file FEProblemBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), FEProblemBase::advanceState(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), FEProblemBase::initElementStatefulProps(), FEProblemBase::initialSetup(), FEProblemBase::initXFEM(), FEProblemBase::meshChanged(), FEProblemBase::reinitMaterials(), and FEProblemBase::swapBackMaterials().

_materials

MaterialWarehouse FEProblemBase::_materials

protectedinherited

Definition at line 2933 of file FEProblemBase.h.

Referenced by FEProblemBase::addFunctorMaterial(), FEProblemBase::addMaterial(), FEProblemBase::getFVMatsAndDependencies(), FEProblemBase::getRegularMaterialsWarehouse(), FEProblemBase::initialSetup(), FEProblemBase::prepareMaterials(), FEProblemBase::reinitMaterials(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsNeighbor(), and FEProblemBase::updateActiveObjects().

_matrix_tag_id_to_tag_name

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

protectedinherited

Reverse map.

Definition at line 1046 of file SubProblem.h.

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

_matrix_tag_name_to_tag_id

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

protectedinherited

The currently declared tags.

Definition at line 1043 of file SubProblem.h.

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

_max_qps

unsigned int FEProblemBase::_max_qps

protectedinherited

Maximum number of quadrature points used in the problem.

Definition at line 3128 of file FEProblemBase.h.

Referenced by FEProblemBase::getMaxQps(), FEProblemBase::reinitDirac(), and FEProblemBase::updateMaxQps().

_max_scalar_order

libMesh::Order FEProblemBase::_max_scalar_order

protectedinherited

Maximum scalar variable order.

Definition at line 3131 of file FEProblemBase.h.

Referenced by FEProblemBase::addAuxScalarVariable(), and FEProblemBase::getMaxScalarOrder().

_mesh

MooseMesh& FEProblemBase::_mesh

protectedinherited

Definition at line 2747 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxVariable(), FEProblemBase::addGhostedBoundary(), FEProblemBase::addGhostedElem(), FEProblemBase::addVariable(), FEProblemBase::checkCoordinateSystems(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::checkUserObjects(), FEProblemBase::computeIndicators(), FEProblemBase::computeMarkers(), FEProblemBase::computeUserObjectsInternal(), DumpObjectsProblem::dumpVariableHelper(), FEProblemBase::duplicateVariableCheck(), FEProblemBase::getCurrentAlgebraicBndNodeRange(), FEProblemBase::getCurrentAlgebraicElementRange(), FEProblemBase::getCurrentAlgebraicNodeRange(), FEProblemBase::getDiracElements(), FEProblemBase::getEvaluableElementRange(), FEProblemBase::getNonlinearEvaluableElementRange(), FEProblemBase::ghostGhostedBoundaries(), FEProblemBase::init(), FEProblemBase::initialAdaptMesh(), FEProblemBase::initialSetup(), FEProblemBase::initXFEM(), mesh(), FEProblemBase::mesh(), FEProblemBase::meshChanged(), FEProblemBase::possiblyRebuildGeomSearchPatches(), FEProblemBase::prepareMaterials(), FEProblemBase::projectSolution(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitElemPhys(), FEProblemBase::setAxisymmetricCoordAxis(), FEProblemBase::setCoordSystem(), FEProblemBase::timestepSetup(), FEProblemBase::uniformRefine(), and FEProblemBase::updateMaxQps().

_mesh_divisions

MooseObjectWarehouse<MeshDivision> FEProblemBase::_mesh_divisions

protectedinherited

Warehouse to store mesh divisions NOTE: this could probably be moved to the MooseMesh instead of the Problem Time (and people's uses) will tell where this fits best.

Definition at line 2899 of file FEProblemBase.h.

Referenced by FEProblemBase::addMeshDivision(), and FEProblemBase::getMeshDivision().

_mortar_data

std::unique_ptr<MortarInterfaceWarehouse> FEProblemBase::_mortar_data

protectedinherited

Definition at line 3049 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::createMortarInterface(), FEProblemBase::getMortarInterface(), FEProblemBase::getMortarInterfaces(), FEProblemBase::init(), FEProblemBase::initialSetup(), FEProblemBase::mortarData(), FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects(), and FEProblemBase::updateMortarMesh().

_multi_apps

ExecuteMooseObjectWarehouse<MultiApp> FEProblemBase::_multi_apps

protectedinherited

MultiApp Warehouse.

Definition at line 2959 of file FEProblemBase.h.

Referenced by FEProblemBase::addMultiApp(), FEProblemBase::backupMultiApps(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::finalizeMultiApps(), FEProblemBase::finishMultiAppStep(), FEProblemBase::getMultiApp(), FEProblemBase::getMultiAppWarehouse(), FEProblemBase::hasMultiApp(), FEProblemBase::hasMultiApps(), FEProblemBase::incrementMultiAppTStep(), FEProblemBase::initialSetup(), FEProblemBase::parentOutputPositionChanged(), FEProblemBase::postExecute(), FEProblemBase::restoreMultiApps(), and FEProblemBase::updateActiveObjects().

_multiapp_fixed_point_convergence_name

std::optional<ConvergenceName> FEProblemBase::_multiapp_fixed_point_convergence_name

protectedinherited

MultiApp fixed point convergence name.

Definition at line 2796 of file FEProblemBase.h.

Referenced by FEProblemBase::getMultiAppFixedPointConvergenceName(), FEProblemBase::hasSetMultiAppFixedPointConvergenceName(), and FEProblemBase::setMultiAppFixedPointConvergenceName().

_name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 363 of file MooseBase.h.

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

_need_to_add_default_multiapp_fixed_point_convergence

bool FEProblemBase::_need_to_add_default_multiapp_fixed_point_convergence

protectedinherited

Flag that the problem needs to add the default fixed point convergence.

Definition at line 2823 of file FEProblemBase.h.

Referenced by FEProblemBase::needToAddDefaultMultiAppFixedPointConvergence(), and FEProblemBase::setNeedToAddDefaultMultiAppFixedPointConvergence().

_need_to_add_default_nonlinear_convergence

bool FEProblemBase::_need_to_add_default_nonlinear_convergence

protectedinherited

Flag that the problem needs to add the default nonlinear convergence.

Definition at line 2821 of file FEProblemBase.h.

Referenced by FEProblemBase::needToAddDefaultNonlinearConvergence(), and FEProblemBase::setNeedToAddDefaultNonlinearConvergence().

_need_to_add_default_steady_state_convergence

bool FEProblemBase::_need_to_add_default_steady_state_convergence

protectedinherited

Flag that the problem needs to add the default steady convergence.

Definition at line 2825 of file FEProblemBase.h.

Referenced by FEProblemBase::needToAddDefaultSteadyStateConvergence(), and FEProblemBase::setNeedToAddDefaultSteadyStateConvergence().

_needs_old_newton_iter

bool FEProblemBase::_needs_old_newton_iter

protectedinherited

Indicates that we need to compute variable values for previous Newton iteration.

Definition at line 3086 of file FEProblemBase.h.

_neighbor_material_props

MaterialPropertyStorage& FEProblemBase::_neighbor_material_props

protectedinherited

Definition at line 2924 of file FEProblemBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), FEProblemBase::advanceState(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), FEProblemBase::getNeighborMaterialPropertyStorage(), FEProblemBase::initElementStatefulProps(), FEProblemBase::initialSetup(), FEProblemBase::meshChanged(), FEProblemBase::reinitMaterialsNeighbor(), and FEProblemBase::swapBackMaterialsNeighbor().

_nl

std::vector<std::shared_ptr<NonlinearSystemBase> > FEProblemBase::_nl

protectedinherited

The nonlinear systems.

Definition at line 2852 of file FEProblemBase.h.

Referenced by FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addKernel(), FEProblemBase::addNodalKernel(), FEProblemBase::addPredictor(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::bumpAllQRuleOrder(), FEProblemBase::bumpVolumeQRuleOrder(), FEProblemBase::checkNonlocalCoupling(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::computeResidualL2Norm(), FEProblemBase::computingPreSMOResidual(), FEProblemBase::currentNlSysNum(), FEProblemBase::customSetup(), DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), FEProblemBase::finalNonlinearResidual(), FEProblemBase::getNonlinearEvaluableElementRange(), FEProblemBase::getNonlinearSystem(), FEProblemBase::getNonlinearSystemBase(), FEProblemBase::init(), FEProblemBase::initialSetup(), FEProblemBase::initXFEM(), FEProblemBase::jacobianSetup(), FEProblemBase::meshChanged(), FEProblemBase::needBoundaryMaterialOnSide(), FEProblemBase::needInterfaceMaterialOnSide(), FEProblemBase::needInternalNeighborSideMaterial(), FEProblemBase::nLinearIterations(), FEProblemBase::nNonlinearIterations(), FEProblemBase::onTimestepBegin(), FEProblemBase::prepareFace(), FEProblemBase::projectInitialConditionOnCustomRange(), FEProblemBase::projectSolution(), FEProblemBase::reinitDirac(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::reinitNodes(), FEProblemBase::reinitNodesNeighbor(), FEProblemBase::reinitScalars(), FEProblemBase::residualSetup(), FEProblemBase::setCurrentNonlinearSystem(), FEProblemBase::setNonlocalCouplingMatrix(), FEProblemBase::setResidual(), FEProblemBase::setResidualObjectParamsAndLog(), FEProblemBase::setupDampers(), FEProblemBase::subdomainSetup(), FEProblemBase::systemBaseNonlinear(), FEProblemBase::updateActiveObjects(), and FEProblemBase::updateMeshXFEM().

_nl_evaluable_local_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_nl_evaluable_local_elem_range

protectedinherited

Definition at line 3172 of file FEProblemBase.h.

Referenced by FEProblemBase::getNonlinearEvaluableElementRange(), and FEProblemBase::meshChanged().

_nl_sys_name_to_num

std::map<NonlinearSystemName, unsigned int> FEProblemBase::_nl_sys_name_to_num

protectedinherited

Map from nonlinear system name to number.

Definition at line 2855 of file FEProblemBase.h.

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

_nl_sys_names

const std::vector<NonlinearSystemName> FEProblemBase::_nl_sys_names

protectedinherited

The nonlinear system names.

Definition at line 2846 of file FEProblemBase.h.

Referenced by DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), FEProblem::FEProblem(), FEProblemBase::FEProblemBase(), and FEProblemBase::getNonlinearSystemNames().

_nonlinear_convergence_names

std::optional<std::vector<ConvergenceName> > FEProblemBase::_nonlinear_convergence_names

protectedinherited

Nonlinear system(s) convergence name(s)

Definition at line 2792 of file FEProblemBase.h.

Referenced by FEProblemBase::getNonlinearConvergenceNames(), and FEProblemBase::setNonlinearConvergenceNames().

_nonlocal_integrated_bcs

MooseObjectWarehouse<IntegratedBCBase> FEProblemBase::_nonlocal_integrated_bcs

protectedinherited

nonlocal integrated_bcs

Definition at line 2911 of file FEProblemBase.h.

Referenced by FEProblemBase::checkNonlocalCoupling(), FEProblemBase::setNonlocalCouplingMatrix(), and FEProblemBase::timestepSetup().

_nonlocal_kernels

MooseObjectWarehouse<KernelBase> FEProblemBase::_nonlocal_kernels

protectedinherited

nonlocal kernels

Definition at line 2908 of file FEProblemBase.h.

Referenced by FEProblemBase::checkNonlocalCoupling(), FEProblemBase::setNonlocalCouplingMatrix(), and FEProblemBase::timestepSetup().

_not_zeroed_tagged_vectors

std::unordered_set<TagID> SubProblem::_not_zeroed_tagged_vectors

protectedinherited

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

Definition at line 1119 of file SubProblem.h.

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

_notify_when_mesh_changes

std::vector<MeshChangedInterface *> FEProblemBase::_notify_when_mesh_changes

protectedinherited

Objects to be notified when the mesh changes.

Definition at line 2989 of file FEProblemBase.h.

Referenced by FEProblemBase::meshChanged(), and FEProblemBase::notifyWhenMeshChanges().

_notify_when_mesh_displaces

std::vector<MeshDisplacedInterface *> FEProblemBase::_notify_when_mesh_displaces

protectedinherited

Objects to be notified when the mesh displaces.

Definition at line 2992 of file FEProblemBase.h.

Referenced by FEProblemBase::meshDisplaced(), and FEProblemBase::notifyWhenMeshDisplaces().

_num_linear_sys

const std::size_t FEProblemBase::_num_linear_sys

protectedinherited

The number of linear systems.

Definition at line 2831 of file FEProblemBase.h.

Referenced by FEProblem::FEProblem(), FEProblemBase::FEProblemBase(), FEProblemBase::numLinearSystems(), and FEProblemBase::numSolverSystems().

_num_nl_sys

const std::size_t FEProblemBase::_num_nl_sys

protectedinherited

The number of nonlinear systems.

Definition at line 2849 of file FEProblemBase.h.

Referenced by ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), FEProblemBase::FEProblemBase(), FEProblemBase::isSolverSystemNonlinear(), FEProblemBase::numNonlinearSystems(), and FEProblemBase::numSolverSystems().

_parallel_barrier_messaging

bool FEProblemBase::_parallel_barrier_messaging

protectedinherited

Whether or not information about how many transfers have completed is printed.

Definition at line 3140 of file FEProblemBase.h.

Referenced by FEProblemBase::backupMultiApps(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::finishMultiAppStep(), FEProblemBase::restoreMultiApps(), and FEProblemBase::setParallelBarrierMessaging().

_pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 366 of file MooseBase.h.

Referenced by AddFVICAction::act(), AddICAction::act(), CreateProblemDefaultAction::act(), CreateProblemAction::act(), SetupMeshAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), AddAuxKernelAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), PiecewiseTabularBase::buildFromFile(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), Eigenvalue::prepareSolverOptions(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

_petsc_option_data_base

PetscOptions FEProblemBase::_petsc_option_data_base

protectedinherited

Definition at line 3163 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::petscOptionsDatabase(), EigenProblem::solve(), FEProblemBase::solve(), FEProblemBase::solveLinearSystem(), and FEProblemBase::~FEProblemBase().

_petsc_options

Moose::PetscSupport::PetscOptions FEProblemBase::_petsc_options

protectedinherited

PETSc option storage.

Definition at line 3161 of file FEProblemBase.h.

Referenced by FEProblemBase::getPetscOptions(), FEProblemBase::solve(), and FEProblemBase::solveLinearSystem().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 124 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

_phi_zero

std::vector<VariablePhiValue> FEProblemBase::_phi_zero

inherited

Definition at line 2255 of file FEProblemBase.h.

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

_point_zero

std::vector<Point> FEProblemBase::_point_zero

inherited

Definition at line 2263 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase().

_prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 127 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_previous_nl_solution_required

bool FEProblemBase::_previous_nl_solution_required

protectedinherited

Indicates we need to save the previous NL iteration variable values.

Definition at line 3089 of file FEProblemBase.h.

Referenced by FEProblemBase::createTagSolutions().

_problem_data

MFEMProblemData MFEMProblem::_problem_data

protected

Definition at line 214 of file MFEMProblem.h.

Referenced by getCoefficients(), getMeshDisplacementGridFunction(), and getProblemData().

_random_data_objects

std::map<std::string, std::unique_ptr<RandomData> > FEProblemBase::_random_data_objects

protectedinherited

A map of objects that consume random numbers.

Definition at line 2977 of file FEProblemBase.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::initialSetup(), FEProblemBase::registerRandomInterface(), and FEProblemBase::timestepSetup().

_real_zero

std::vector<Real> FEProblemBase::_real_zero

inherited

Convenience zeros.

Definition at line 2252 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase().

_reinit_displaced_elem

bool FEProblemBase::_reinit_displaced_elem

protectedinherited

Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.

Definition at line 3052 of file FEProblemBase.h.

Referenced by FEProblemBase::addDiracKernel(), FEProblemBase::addFVKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), FEProblemBase::addKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareFace(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElem(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodes(), FEProblemBase::reinitNodesNeighbor(), FEProblemBase::reinitScalars(), FEProblemBase::setAuxKernelParamsAndLog(), and FEProblemBase::setCurrentSubdomainID().

_reinit_displaced_face

bool FEProblemBase::_reinit_displaced_face

protectedinherited

Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.

Definition at line 3054 of file FEProblemBase.h.

Referenced by FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addMaterialHelper(), FEProblemBase::addUserObject(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareFace(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitNodeFace(), FEProblemBase::setAuxKernelParamsAndLog(), and FEProblemBase::setCurrentSubdomainID().

_reinit_displaced_neighbor

bool FEProblemBase::_reinit_displaced_neighbor

protectedinherited

Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.

Definition at line 3056 of file FEProblemBase.h.

Referenced by FEProblemBase::addDGKernel(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addMaterialHelper(), FEProblemBase::addUserObject(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitNeighbor(), and FEProblemBase::setCurrentSubdomainID().

_reporter_data

ReporterData FEProblemBase::_reporter_data

protectedinherited

Definition at line 2953 of file FEProblemBase.h.

Referenced by FEProblemBase::advanceState(), FEProblemBase::checkDuplicatePostprocessorVariableNames(), FEProblemBase::getPostprocessorValueByName(), FEProblemBase::getReporterData(), FEProblemBase::getVectorPostprocessorValueByName(), FEProblemBase::hasPostprocessorValueByName(), FEProblemBase::initialSetup(), FEProblemBase::joinAndFinalize(), FEProblemBase::restoreSolutions(), FEProblemBase::setPostprocessorValueByName(), and FEProblemBase::setVectorPostprocessorValueByName().

_restartable_app

MooseApp& Restartable::_restartable_app

protectedinherited

Reference to the application.

Definition at line 234 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp(), and Restartable::registerRestartableNameWithFilterOnApp().

_restartable_read_only

const bool Restartable::_restartable_read_only

protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 243 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

_restartable_system_name

const std::string Restartable::_restartable_system_name

protectedinherited

The system name this object is in.

Definition at line 237 of file Restartable.h.

Referenced by Restartable::restartableName().

_restartable_tid

const THREAD_ID Restartable::_restartable_tid

protectedinherited

The thread ID for this object.

Definition at line 240 of file Restartable.h.

Referenced by Restartable::declareRestartableDataHelper().

_safe_access_tagged_matrices

bool SubProblem::_safe_access_tagged_matrices

protectedinherited

Is it safe to retrieve data from tagged matrices.

Definition at line 1110 of file SubProblem.h.

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

_safe_access_tagged_vectors

bool SubProblem::_safe_access_tagged_vectors

protectedinherited

Is it safe to retrieve data from tagged vectors.

Definition at line 1113 of file SubProblem.h.

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

_scalar_ics

ScalarInitialConditionWarehouse FEProblemBase::_scalar_ics

protectedinherited

Definition at line 2917 of file FEProblemBase.h.

Referenced by FEProblemBase::addInitialCondition(), FEProblemBase::initialSetup(), FEProblemBase::projectInitialConditionOnCustomRange(), and FEProblemBase::projectSolution().

_scalar_zero

std::vector<VariableValue> FEProblemBase::_scalar_zero

inherited

Definition at line 2253 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::reinitDirac(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_second_phi_zero

std::vector<VariablePhiSecond> FEProblemBase::_second_phi_zero

inherited

Definition at line 2262 of file FEProblemBase.h.

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

_second_zero

std::vector<VariableSecond> FEProblemBase::_second_zero

inherited

Definition at line 2260 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::reinitDirac(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_skip_exception_check

bool FEProblemBase::_skip_exception_check

protectedinherited

If or not skip 'exception and stop solve'.

Definition at line 3071 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::initialSetup(), and FEProblemBase::skipExceptionCheck().

_snesmf_reuse_base

bool FEProblemBase::_snesmf_reuse_base

protectedinherited

If or not to resuse the base vector for matrix-free calculation.

Definition at line 3068 of file FEProblemBase.h.

Referenced by FEProblemBase::setSNESMFReuseBase(), and FEProblemBase::useSNESMFReuseBase().

_snesmf_reuse_base_set_by_user

bool FEProblemBase::_snesmf_reuse_base_set_by_user

protectedinherited

If or not _snesmf_reuse_base is set by user.

Definition at line 3074 of file FEProblemBase.h.

Referenced by FEProblemBase::isSNESMFReuseBaseSetbyUser(), and FEProblemBase::setSNESMFReuseBase().

_solve

const bool& FEProblemBase::_solve

protectedinherited

Whether or not to actually solve the nonlinear system.

Definition at line 2811 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity(), FEProblemBase::FEProblemBase(), FEProblemBase::init(), FEProblemBase::shouldSolve(), EigenProblem::solve(), FEProblemBase::solve(), FEProblemBase::solveLinearSystem(), EigenProblem::solverSystemConverged(), and FEProblemBase::solverSystemConverged().

_solver_params

std::vector<SolverParams> FEProblemBase::_solver_params

protectedinherited

Definition at line 3100 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::solve(), FEProblemBase::solveLinearSystem(), and FEProblemBase::solverParams().

_solver_sys_name_to_num

std::map<SolverSystemName, unsigned int> FEProblemBase::_solver_sys_name_to_num

protectedinherited

Map connecting solver system names with their respective systems.

Definition at line 2870 of file FEProblemBase.h.

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

_solver_sys_names

std::vector<SolverSystemName> FEProblemBase::_solver_sys_names

protectedinherited

The union of nonlinear and linear system names.

Definition at line 2873 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::getSolverSystemNames(), FEProblemBase::getSystemBase(), Moose::PetscSupport::setSinglePetscOption(), and FEProblemBase::solverSysNum().

_solver_systems

std::vector<std::shared_ptr<SolverSystem> > FEProblemBase::_solver_systems

protectedinherited

Combined container to base pointer of every solver system.

Definition at line 2864 of file FEProblemBase.h.

Referenced by FEProblemBase::addObjectParamsHelper(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addVariable(), FEProblemBase::advanceState(), FEProblemBase::computeSystems(), FEProblemBase::copySolutionsBackwards(), FEProblemBase::createQRules(), FEProblemBase::createTagMatrices(), FEProblemBase::createTagSolutions(), FEProblemBase::createTagVectors(), FEProblemBase::determineSolverSystem(), DumpObjectsProblem::DumpObjectsProblem(), FEProblemBase::duplicateVariableCheck(), EigenProblem::EigenProblem(), ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), FEProblemBase::getActualFieldVariable(), FEProblemBase::getArrayVariable(), FEProblemBase::getScalarVariable(), FEProblemBase::getSolverSystem(), FEProblemBase::getStandardVariable(), FEProblemBase::getSystem(), FEProblemBase::getSystemBase(), FEProblemBase::getVariable(), FEProblemBase::getVariableNames(), FEProblemBase::getVectorVariable(), FEProblemBase::hasScalarVariable(), FEProblemBase::hasSolverVariable(), FEProblemBase::hasVariable(), FEProblem::init(), FEProblemBase::init(), FEProblemBase::initialSetup(), FEProblemBase::meshChanged(), FEProblemBase::needSolutionState(), FEProblemBase::outputStep(), FEProblemBase::projectSolution(), FEProblemBase::reinitElem(), FEProblemBase::reinitElemPhys(), FEProblemBase::restoreOldSolutions(), FEProblemBase::restoreSolutions(), FEProblemBase::saveOldSolutions(), FEProblemBase::setAuxKernelParamsAndLog(), FEProblemBase::setCurrentSubdomainID(), Moose::PetscSupport::setSinglePetscOption(), FEProblemBase::setVariableAllDoFMap(), FEProblemBase::solverSystemConverged(), FEProblemBase::systemBaseSolver(), FEProblemBase::systemNumForVariable(), and FEProblemBase::timestepSetup().

_solver_var_to_sys_num

std::map<SolverVariableName, unsigned int> FEProblemBase::_solver_var_to_sys_num

protectedinherited

Map connecting variable names with their respective solver systems.

Definition at line 2867 of file FEProblemBase.h.

Referenced by FEProblemBase::addVariable(), and FEProblemBase::determineSolverSystem().

_steady_state_convergence_name

std::optional<ConvergenceName> FEProblemBase::_steady_state_convergence_name

protectedinherited

Steady-state detection convergence name.

Definition at line 2798 of file FEProblemBase.h.

Referenced by FEProblemBase::getSteadyStateConvergenceName(), FEProblemBase::hasSetSteadyStateConvergenceName(), and FEProblemBase::setSteadyStateConvergenceName().

_subspace_dim

std::map<std::string, unsigned int> FEProblemBase::_subspace_dim

protectedinherited

Dimension of the subspace spanned by the vectors with a given prefix.

Definition at line 2886 of file FEProblemBase.h.

Referenced by FEProblemBase::initNullSpaceVectors(), and FEProblemBase::subspaceDim().

_t_step

int& FEProblemBase::_t_step

protectedinherited

Definition at line 2816 of file FEProblemBase.h.

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

_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().

_time

Real& FEProblemBase::_time

protectedinherited

Definition at line 2814 of file FEProblemBase.h.

Referenced by FEProblemBase::execMultiApps(), FEProblemBase::FEProblemBase(), FEProblemBase::incrementMultiAppTStep(), FEProblemBase::initialSetup(), FEProblemBase::time(), and FEProblemBase::updateMeshXFEM().

_time_old

Real& FEProblemBase::_time_old

protectedinherited

Definition at line 2815 of file FEProblemBase.h.

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

_to_multi_app_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_to_multi_app_transfers

protectedinherited

Transfers executed just before MultiApps to transfer data to them.

Definition at line 2968 of file FEProblemBase.h.

Referenced by FEProblemBase::addTransfer(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::getMultiAppTransferWarehouse(), FEProblemBase::getTransfers(), FEProblemBase::initialSetup(), and FEProblemBase::updateActiveObjects().

_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_transfers

protectedinherited

Normal Transfers.

Definition at line 2965 of file FEProblemBase.h.

Referenced by FEProblemBase::addTransfer(), FEProblemBase::execTransfers(), FEProblemBase::initialSetup(), and FEProblemBase::updateActiveObjects().

_transient

bool FEProblemBase::_transient

protectedinherited

Definition at line 2813 of file FEProblemBase.h.

Referenced by FEProblemBase::isTransient(), and FEProblemBase::transient().

_transient_multi_apps

ExecuteMooseObjectWarehouse<TransientMultiApp> FEProblemBase::_transient_multi_apps

protectedinherited

Storage for TransientMultiApps (only needed for calling 'computeDT')

Definition at line 2962 of file FEProblemBase.h.

Referenced by FEProblemBase::addMultiApp(), FEProblemBase::computeMultiAppsDT(), and FEProblemBase::updateActiveObjects().

_type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 360 of file MooseBase.h.

Referenced by ExplicitTimeIntegrator::ExplicitTimeIntegrator(), FEProblemSolve::FEProblemSolve(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), FillBetweenCurvesGenerator::generate(), ExplicitTimeIntegrator::init(), FEProblemBase::init(), MooseBase::MooseBase(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), FEProblemBase::solverTypeString(), and MooseBase::type().

_uo_aux_state_check

const bool FEProblemBase::_uo_aux_state_check

protectedinherited

Whether or not checking the state of uo/aux evaluation.

Definition at line 3125 of file FEProblemBase.h.

Referenced by FEProblemBase::execute(), and FEProblemBase::hasUOAuxStateCheck().

_uo_jacobian_moose_vars

std::vector<std::vector<const MooseVariableFEBase *> > FEProblemBase::_uo_jacobian_moose_vars

protectedinherited

Definition at line 3095 of file FEProblemBase.h.

Referenced by FEProblemBase::checkUserObjectJacobianRequirement(), FEProblemBase::FEProblemBase(), FEProblemBase::getUserObjectJacobianVariables(), FEProblemBase::initialSetup(), and FEProblemBase::meshChanged().

_use_hash_table_matrix_assembly

const bool FEProblemBase::_use_hash_table_matrix_assembly

protectedinherited

Whether to assemble matrices using hash tables instead of preallocating matrix memory.

This can be a good option if the sparsity pattern changes throughout the course of the simulation

Definition at line 3188 of file FEProblemBase.h.

Referenced by EigenProblem::EigenProblem(), and FEProblem::FEProblem().

_using_ad_mat_props

bool FEProblemBase::_using_ad_mat_props

protectedinherited

Automatic differentiaion (AD) flag which indicates whether any consumer has requested an AD material property or whether any suppier has declared an AD material property.

Definition at line 3181 of file FEProblemBase.h.

_using_default_nl

const bool FEProblemBase::_using_default_nl

protectedinherited

Boolean to check if we have the default nonlinear system.

Definition at line 2843 of file FEProblemBase.h.

_var_dof_map

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

inherited

Definition at line 674 of file SubProblem.h.

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

_vector_curl_zero

std::vector<VectorVariableCurl> FEProblemBase::_vector_curl_zero

inherited

Definition at line 2265 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::reinitDirac(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_vector_zero

std::vector<VectorVariableValue> FEProblemBase::_vector_zero

inherited

Definition at line 2264 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::reinitDirac(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_verbose_multiapps

bool FEProblemBase::_verbose_multiapps

protectedinherited

Whether or not to be verbose with multiapps.

Definition at line 3146 of file FEProblemBase.h.

Referenced by FEProblemBase::backupMultiApps(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::finishMultiAppStep(), FEProblemBase::restoreMultiApps(), FEProblemBase::setVerboseProblem(), and FEProblemBase::verboseMultiApps().

_verbose_restore

bool FEProblemBase::_verbose_restore

protectedinherited

Whether or not to be verbose on solution restoration post a failed time step.

Definition at line 3149 of file FEProblemBase.h.

Referenced by FEProblemBase::restoreSolutions(), and FEProblemBase::setVerboseProblem().

_verbose_setup

MooseEnum FEProblemBase::_verbose_setup

protectedinherited

Whether or not to be verbose during setup.

Definition at line 3143 of file FEProblemBase.h.

Referenced by FEProblemBase::logAdd(), and FEProblemBase::setVerboseProblem().

_xfem

std::shared_ptr<XFEMInterface> FEProblemBase::_xfem

protectedinherited

Pointer to XFEM controller.

Definition at line 3043 of file FEProblemBase.h.

Referenced by FEProblemBase::getXFEM(), FEProblemBase::haveXFEM(), FEProblemBase::initXFEM(), and FEProblemBase::updateMeshXFEM().

_zero

std::vector<VariableValue> FEProblemBase::_zero

inherited

Definition at line 2254 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::reinitDirac(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_zero_block_material_props

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

protectedinherited

Set of properties returned as zero properties.

Definition at line 1060 of file SubProblem.h.

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

_zero_boundary_material_props

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

protectedinherited

Definition at line 1061 of file SubProblem.h.

Referenced by SubProblem::checkBoundaryMatProps(), and SubProblem::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(), Factory::getValidParams(), ActionFactory::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 MooseObject::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(), MooseObjectUnitTest::buildObjects(), ActionFactory::create(), 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 82 of file MooseObject.h.

---

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

• include/mfem/problem/MFEMProblem.h
• src/mfem/problem/MFEMProblem.C