Specialization of SubProblem for solving nonlinear equations plus auxiliary equations. More...

#include <FEProblem.h>

Inheritance diagram for FEProblem:

Public Member Functions
	FEProblem (const InputParameters &parameters)

virtual bool	getUseNonlinear () const

virtual void	setUseNonlinear (bool use_nonlinear)

virtual void	setInputParametersFEProblem (InputParameters &parameters) override

NonlinearSystem &	getNonlinearSystem () override

virtual void	addLineSearch (const InputParameters &parameters) override
	add a MOOSE line search More...

virtual EquationSystems &	es () override

virtual MooseMesh &	mesh () override

virtual Moose::CoordinateSystemType	getCoordSystem (SubdomainID sid) override

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

void	setCouplingMatrix (std::unique_ptr< CouplingMatrix > cm)
	Set custom coupling matrix. More...

void	setCouplingMatrix (CouplingMatrix *cm)

const CouplingMatrix *	couplingMatrix ()

void	setNonlocalCouplingMatrix ()
	Set custom coupling matrix for variables requiring nonlocal contribution. More...

bool	areCoupled (unsigned int ivar, unsigned int jvar)

std::vector< std::pair< MooseVariableFEBase , MooseVariableFEBase > > &	couplingEntries (THREAD_ID tid)

std::vector< std::pair< MooseVariableFEBase , MooseVariableFEBase > > &	nonlocalCouplingEntries (THREAD_ID tid)

virtual MooseNonlinearConvergenceReason	checkNonlinearConvergence (std::string &msg, const PetscInt it, const Real xnorm, const Real snorm, const Real fnorm, const Real rtol, const Real stol, const Real abstol, const PetscInt nfuncs, const PetscInt max_funcs, const PetscBool force_iteration, const Real initial_residual_before_preset_bcs, const Real div_threshold)
	Check for converence of the nonlinear solution. More...

virtual MooseLinearConvergenceReason	checkLinearConvergence (std::string &msg, const PetscInt n, const Real rnorm, const Real rtol, const Real atol, const Real dtol, const PetscInt maxits)
	Check for convergence of the linear solution. More...

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

virtual MooseVariableFEBase &	getVariable (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) override
	Returns the variable reference for requested variable which must be of the expected_var_type (Nonlinear vs. More...

virtual MooseVariable &	getStandardVariable (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 (THREAD_ID tid, const std::string &var_name) override
	Returns the variable reference for requested VectorMooseVariable 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 (THREAD_ID tid, const std::string &var_name) override
	Returns the scalar variable reference from whichever system contains it. More...

virtual System &	getSystem (const std::string &var_name) override
	Returns the equation system containing the variable provided. More...

virtual void	setActiveElementalMooseVariables (const std::set< MooseVariableFEBase *> &moose_vars, THREAD_ID tid) override
	Set the MOOSE variables to be reinited on each element. More...

virtual void	clearActiveElementalMooseVariables (THREAD_ID tid) override
	Clear the active elemental MooseVariableFEBase. More...

virtual void	clearActiveFEVariableCoupleableMatrixTags (THREAD_ID tid) override

virtual void	clearActiveFEVariableCoupleableVectorTags (THREAD_ID tid) override

virtual void	setActiveFEVariableCoupleableVectorTags (std::set< TagID > &vtags, THREAD_ID tid) override

virtual void	setActiveFEVariableCoupleableMatrixTags (std::set< TagID > &mtags, THREAD_ID tid) override

virtual void	clearActiveScalarVariableCoupleableMatrixTags (THREAD_ID tid) override

virtual void	clearActiveScalarVariableCoupleableVectorTags (THREAD_ID tid) override

virtual void	setActiveScalarVariableCoupleableVectorTags (std::set< TagID > &vtags, THREAD_ID tid) override

virtual void	setActiveScalarVariableCoupleableMatrixTags (std::set< TagID > &mtags, THREAD_ID tid) override

virtual void	setActiveMaterialProperties (const std::set< unsigned int > &mat_prop_ids, THREAD_ID tid) override
	Record and set the material properties required by the current computing thread. More...

virtual void	clearActiveMaterialProperties (THREAD_ID tid) override
	Clear the active material properties. More...

virtual void	createQRules (QuadratureType type, Order order, Order volume_order=INVALID_ORDER, Order face_order=INVALID_ORDER)

unsigned int	getMaxQps () const

unsigned int	getMaxShapeFunctions () const

Order	getMaxScalarOrder () const

void	checkNonlocalCoupling ()

void	checkUserObjectJacobianRequirement (THREAD_ID tid)

void	setVariableAllDoFMap (const std::vector< MooseVariableFEBase *> moose_vars)

const std::vector< MooseVariableFEBase * > &	getUserObjectJacobianVariables (THREAD_ID tid) const

virtual Assembly &	assembly (THREAD_ID tid) override

virtual std::vector< VariableName >	getVariableNames ()
	Returns a list of all the variables in the problem (both from the NL and Aux systems. More...

virtual void	addExtraVectors ()
	A place to add extra vectors to the simulation. More...

virtual void	initialSetup ()

virtual void	timestepSetup ()

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

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

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

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

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

virtual void	setNeighborSubdomainID (const Elem *elem, THREAD_ID tid)

virtual void	prepareAssembly (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, THREAD_ID tid)

virtual bool	reinitDirac (const Elem *elem, 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, THREAD_ID tid) override

virtual void	reinitElemPhys (const Elem *elem, const std::vector< Point > &phys_points_in_elem, THREAD_ID tid, bool suppress_displaced_init=false) override

virtual void	reinitElemFace (const Elem *elem, unsigned int side, BoundaryID bnd_id, THREAD_ID tid) override

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

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

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

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

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

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

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

virtual void	reinitScalars (THREAD_ID tid) override

virtual void	reinitOffDiagScalars (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, THREAD_ID tid)

virtual void	neighborSubdomainSetup (SubdomainID subdomain, THREAD_ID tid)

virtual void	newAssemblyArray (NonlinearSystemBase &nl)

virtual void	initNullSpaceVectors (const InputParameters &parameters, NonlinearSystemBase &nl)

virtual void	init () override

virtual void	solve () override

const ConstElemRange &	getEvaluableElementRange ()

virtual void	setException (const std::string &message)
	Set an exception. More...

virtual bool	hasException ()
	Whether or not an exception has occurred. More...

virtual void	checkExceptionAndStopSolve ()
	Check to see if an exception has occurred on any processor and stop the solve. More...

virtual bool	converged () override

virtual unsigned int	nNonlinearIterations () const override

virtual unsigned int	nLinearIterations () const override

virtual Real	finalNonlinearResidual () const override

virtual bool	computingInitialResidual () 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

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

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

void	initPetscOutput ()
	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...

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

virtual bool	hasFunction (const std::string &name, THREAD_ID tid=0)

virtual Function &	getFunction (const std::string &name, THREAD_ID tid=0)

virtual void	lineSearch ()
	execute MOOSE line search More...

std::shared_ptr< LineSearch >	getLineSearch ()
	getter for the MOOSE line search More...

virtual void	addDistribution (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 (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, THREAD_ID tid=0)

NonlinearSystemBase &	getNonlinearSystemBase ()

const NonlinearSystemBase &	getNonlinearSystemBase () const

virtual void	addVariable (const std::string &var_name, const FEType &type, Real scale_factor, const std::set< SubdomainID > *const active_subdomains=NULL)

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

virtual void	addKernel (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	addBoundaryCondition (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	addAuxVariable (const std::string &var_name, const FEType &type, const std::set< SubdomainID > *const active_subdomains=NULL)

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

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

virtual void	addAuxScalarKernel (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	addInterfaceKernel (const std::string &kernel_name, const std::string &name, InputParameters parameters)

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

void	projectSolution ()

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

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

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

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

virtual void	prepareMaterials (SubdomainID blk_id, THREAD_ID tid)
	Add the MooseVariables that the current materials depend on to the dependency list. More...

virtual void	reinitMaterials (SubdomainID blk_id, THREAD_ID tid, bool swap_stateful=true)

virtual void	reinitMaterialsFace (SubdomainID blk_id, THREAD_ID tid, bool swap_stateful=true)

virtual void	reinitMaterialsNeighbor (SubdomainID blk_id, THREAD_ID tid, bool swap_stateful=true)

virtual void	reinitMaterialsBoundary (BoundaryID boundary_id, THREAD_ID tid, bool swap_stateful=true)

virtual void	swapBackMaterials (THREAD_ID tid)

virtual void	swapBackMaterialsFace (THREAD_ID tid)

virtual void	swapBackMaterialsNeighbor (THREAD_ID tid)

virtual void	addPostprocessor (std::string pp_name, const std::string &name, InputParameters parameters)

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

void	initPostprocessorData (const std::string &name)
	Initializes the postprocessor data. More...

void	initVectorPostprocessorData (const std::string &name)
	Initialize the VectorPostprocessor data. More...

virtual void	addUserObject (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
	Get the user object by its name. More...

bool	hasUserObject (const std::string &name) const
	Check if there if a user object of given name. More...

bool	hasPostprocessor (const std::string &name)
	Check existence of the postprocessor. More...

PostprocessorValue &	getPostprocessorValue (const PostprocessorName &name)
	Get a reference to the value associated with the postprocessor. More...

PostprocessorValue &	getPostprocessorValueOld (const std::string &name)
	Get the reference to the old value of a post-processor. More...

PostprocessorValue &	getPostprocessorValueOlder (const std::string &name)
	Get the reference to the older value of a post-processor. More...

bool	hasVectorPostprocessor (const std::string &name)
	Check existence of the VectorPostprocessor. More...

VectorPostprocessorValue &	getVectorPostprocessorValue (const VectorPostprocessorName &name, const std::string &vector_name)
	DEPRECATED: Use the new version where you need to specify whether or not the vector must be broadcast. More...

VectorPostprocessorValue &	getVectorPostprocessorValue (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast)
	Get a reference to the value associated with the VectorPostprocessor. More...

VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &name, const std::string &vector_name)
	DEPRECATED: Use the new version where you need to specify whether or not the vector must be broadcast. More...

VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &name, const std::string &vector_name, bool needs_broadcast)
	Get the reference to the old value of a post-processor. More...

ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValue (const VectorPostprocessorName &vpp_name, const std::string &vector_name)
	Return the scatter value for the post processor. More...

ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOld (const VectorPostprocessorName &vpp_name, const std::string &vector_name)
	Return the scatter value for the post processor. More...

VectorPostprocessorValue &	declareVectorPostprocessorVector (const VectorPostprocessorName &name, const std::string &vector_name, bool contains_complete_history, bool is_broadcast)
	Declare a new VectorPostprocessor vector. More...

bool	vectorPostprocessorHasVectors (const std::string &vpp_name)
	Whether or not the specified VectorPostprocessor has declared any vectors. More...

const std::vector< std::pair< std::string, VectorPostprocessorData::VectorPostprocessorState > > &	getVectorPostprocessorVectors (const std::string &vpp_name)
	Get the vectors for a specific VectorPostprocessor. More...

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

void	setupDampers ()

bool	hasDampers ()
	Whether or not this system has dampers. More...

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

virtual void	addMarker (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, MultiAppTransfer::DIRECTION direction) const
	Get Transfers by ExecFlagType and direction. More...

void	execMultiAppTransfers (ExecFlagType type, MultiAppTransfer::DIRECTION direction)
	Execute MultiAppTransfers associate 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)
	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...

virtual void	addTransfer (const std::string &transfer_name, const std::string &name, InputParameters parameters)
	Add a Transfer to the problem. More...

void	execTransfers (ExecFlagType type)
	Execute the Transfers associated with the ExecFlagType. More...

void	computeTransientImplicitResidual (Real time, const NumericVector< Number > &u, const NumericVector< Number > &udot, const NumericVector< Number > &udotdot, NumericVector< Number > &residual)
	Evaluates transient residual G in canonical semidiscrete form G(t,U,Udot,Udotdot) = F(t,U) More...

void	computeTransientImplicitJacobian (Real time, const NumericVector< Number > &u, const NumericVector< Number > &udot, const NumericVector< Number > &udotdot, Real duDotDu_shift, Real duDotDotDu_shift, SparseMatrix< Number > &jacobian)
	Evaluates transient Jacobian J_a = dG/dU + a*dG/dUdot from canonical semidiscrete form G(t,U,Udot) = F(t,U) 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 (NonlinearImplicitSystem &sys, const NumericVector< Number > &soln, NumericVector< Number > &residual)
	This function is called by Libmesh to form a residual. More...

void	computeResidual (NonlinearImplicitSystem &sys, const NumericVector< Number > &soln, NumericVector< Number > &residual)
	This function is called by Libmesh to form a residual. More...

virtual void	computeResidual (const NumericVector< Number > &soln, NumericVector< Number > &residual)
	Form a residual with default tags (nontime, time, residual). More...

virtual void	computeResidualTag (const NumericVector< Number > &soln, NumericVector< Number > &residual, TagID tag)
	Form a residual vector for a given tag. More...

virtual void	computeResidualType (const NumericVector< Number > &soln, NumericVector< Number > &residual, TagID tag)
	Form a residual vector for a given tag and "residual" tag. More...

virtual void	computeResidualInternal (const NumericVector< Number > &soln, NumericVector< 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 (NonlinearImplicitSystem &sys, const NumericVector< Number > &soln, SparseMatrix< Number > &jacobian)
	Form a Jacobian matrix. More...

virtual void	computeJacobian (const NumericVector< Number > &soln, SparseMatrix< Number > &jacobian)
	Form a Jacobian matrix with the default tag (system). More...

virtual void	computeJacobianTag (const NumericVector< Number > &soln, SparseMatrix< Number > &jacobian, TagID tag)
	Form a Jacobian matrix for a given tag. More...

virtual void	computeJacobianInternal (const NumericVector< Number > &soln, SparseMatrix< 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)
	Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditioning matrices. More...

virtual void	computeJacobianBlock (SparseMatrix< Number > &jacobian, libMesh::System &precond_system, unsigned int ivar, unsigned int jvar)
	Really not a good idea to use this. More...

virtual Real	computeDamping (const NumericVector< Number > &soln, const NumericVector< Number > &update)

virtual bool	shouldUpdateSolution ()
	Check to see whether the problem should update the solution. More...

virtual bool	updateSolution (NumericVector< Number > &vec_solution, NumericVector< Number > &ghosted_solution)
	Update the solution. More...

virtual void	predictorCleanup (NumericVector< Number > &ghosted_solution)
	Perform cleanup tasks after application of predictor to solution vector. More...

virtual void	computeBounds (NonlinearImplicitSystem &sys, NumericVector< Number > &lower, NumericVector< Number > &upper)

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

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

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

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

virtual void	computeIndicatorsAndMarkers ()

virtual void	computeIndicators ()

virtual void	computeMarkers ()

virtual void	addResidual (THREAD_ID tid) override

virtual void	addResidualNeighbor (THREAD_ID tid) override

virtual void	addResidualScalar (THREAD_ID tid=0)

virtual void	cacheResidual (THREAD_ID tid) override

virtual void	cacheResidualNeighbor (THREAD_ID tid) override

virtual void	addCachedResidual (THREAD_ID tid) override

virtual void	addCachedResidualDirectly (NumericVector< Number > &residual, 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< Number > &residual, THREAD_ID tid) override

virtual void	setResidualNeighbor (NumericVector< Number > &residual, THREAD_ID tid) override

virtual void	addJacobian (THREAD_ID tid) override

virtual void	addJacobianNeighbor (THREAD_ID tid) override

virtual void	addJacobianNeighbor (SparseMatrix< 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, THREAD_ID tid) override

virtual void	addJacobianBlock (SparseMatrix< Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices, THREAD_ID tid) override

virtual void	addJacobianScalar (THREAD_ID tid=0)

virtual void	addJacobianOffDiagScalar (unsigned int ivar, THREAD_ID tid=0)

virtual void	cacheJacobian (THREAD_ID tid) override

virtual void	cacheJacobianNeighbor (THREAD_ID tid) override

virtual void	addCachedJacobian (THREAD_ID tid) override

virtual void	prepareShapes (unsigned int var, THREAD_ID tid) override

virtual void	prepareFaceShapes (unsigned int var, THREAD_ID tid) override

virtual void	prepareNeighborShapes (unsigned int var, THREAD_ID tid) override

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

virtual std::shared_ptr< DisplacedProblem >	getDisplacedProblem ()

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

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 InitialConditionWarehouse &	getInitialConditionWarehouse () const
	Return InitialCondition storage. More...

SolverParams &	solverParams ()
	Get the solver parameters. 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 () override
	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...

virtual void	checkProblemIntegrity ()
	Method called to perform a series of sanity checks before a simulation is run. More...

void	serializeSolution ()

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 (bool flag)
	Set flag to indicate whether kernel 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	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 &	getResidualMaterialsWarehouse () const

const MaterialWarehouse &	getJacobianMaterialsWarehouse () const

const MaterialWarehouse &	getDiscreteMaterialWarehouse () const

std::shared_ptr< Material >	getMaterial (std::string name, Moose::MaterialDataType type, THREAD_ID tid=0, bool no_warn=false)
	Return a pointer to a Material object. More...

std::shared_ptr< MaterialData >	getMaterialData (Moose::MaterialDataType type, THREAD_ID tid=0)

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	ignoreZerosInJacobian () const

void	setIgnoreZerosInJacobian (bool state)

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	computeUserObjects (const ExecFlagType &type, const Moose::AuxGroup &group)
	Call compute methods on UserObjects. More...

virtual void	computeAuxiliaryKernels (const ExecFlagType &type)
	Call compute methods on AuxKernels. 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...

bool	skipAdditionalRestartData () const
	Whether or not to skip loading the additional data when restarting. 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 ()

const VectorPostprocessorData &	getVectorPostprocessorData () const

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

bool	isSNESMFReuseBaseSetbyUser ()
	Return a flag to indicate if _snesmf_reuse_base is set by users. More...

void	usingADMatProps (bool using_ad_mat_props)
	Set the global 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...

bool	usingADMatProps () const
	Whether any object has requested/supplied an AD material property. More...

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

virtual bool	checkNonlocalCouplingRequirement ()

bool	defaultGhosting ()
	Whether or not the user has requested default ghosting ot be on. More...

virtual TagID	addVectorTag (TagName tag_name)
	Create a Tag. More...

virtual TagID	getVectorTagID (const TagName &tag_name)
	Get a TagID from a TagName. More...

virtual TagName	vectorTagName (TagID tag)
	Retrieve the name associated with a TagID. More...

virtual std::map< TagName, TagID > &	getVectorTags ()
	Return all vector tags, where a tag is represented by a map from name to ID. More...

virtual bool	vectorTagExists (TagID tag)
	Check to see if a particular Tag exists. More...

bool	vectorTagExists (const TagName &tag_name)
	Check to see if a particular Tag exists by using Tag name. More...

virtual unsigned int	numVectorTags ()
	The total number of tags. More...

virtual TagID	addMatrixTag (TagName tag_name)
	Create a Tag. More...

virtual TagID	getMatrixTagID (const TagName &tag_name)
	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)
	Check to see if a particular Tag exists. More...

virtual bool	matrixTagExists (TagID tag_id)
	Check to see if a particular Tag exists. More...

virtual unsigned int	numMatrixTags ()
	The total number of tags. More...

virtual std::map< TagName, TagID > &	getMatrixTags ()
	Return all matrix tags in the sytem, where a tag is represented by a map from name to ID. More...

virtual const std::set< MooseVariableFEBase * > &	getActiveElementalMooseVariables (THREAD_ID tid) const
	Get the MOOSE variables to be reinited on each element. More...

virtual bool	hasActiveElementalMooseVariables (THREAD_ID tid) const
	Whether or not a list of active elemental moose variables has been set. More...

virtual const std::set< unsigned int > &	getActiveMaterialProperties (THREAD_ID tid) const
	Get the material properties required by the current computing thread. More...

virtual bool	hasActiveMaterialProperties (THREAD_ID tid) const
	Method to check whether or not a list of active material roperties has been set. More...

unsigned int	getAxisymmetricRadialCoord () const
	Returns the desired radial direction for RZ coordinate transformation. More...

virtual DiracKernelInfo &	diracKernelInfo ()

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

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 CouplingMatrix &	nonlocalCouplingMatrix () const

virtual const bool &	currentlyComputingJacobian () const
	Returns true if the problem is in the process of computing Jacobian. More...

virtual void	setCurrentlyComputingJacobian (const bool &flag)

bool &	computingNonlinearResid ()
	Check whether residual being evaulated is non-linear. More...

bool	safeAccessTaggedMatrices ()
	Is it safe to access the tagged matrices. More...

bool	safeAccessTaggedVectors ()
	Is it safe to access the tagged vectors. More...

std::set< TagID > &	getActiveScalarVariableCoupleableVectorTags (THREAD_ID tid)

std::set< TagID > &	getActiveScalarVariableCoupleableMatrixTags (THREAD_ID tid)

std::set< TagID > &	getActiveFEVariableCoupleableVectorTags (THREAD_ID tid)

std::set< TagID > &	getActiveFEVariableCoupleableMatrixTags (THREAD_ID tid)

void	_setCLIOption ()
	For Internal Use. More...

virtual void	terminateSolve ()
	Allow objects to request clean termination of the solve. More...

virtual bool	isSolveTerminationRequested ()
	Check of termination has been requested. More...

const std::string &	type () const
	Get the type of this object. More...

const std::string &	name () const
	Get the name of the object. More...

const InputParameters &	parameters () const
	Get the parameters of the object. More...

template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a 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...

MooseApp &	getMooseApp () const
	Get the MooseApp this object is associated with. More...

virtual bool	enabled () const
	Return the enabled status of the object. More...

template<typename... Args>
void	paramError (const std::string &param, Args... args)
	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)
	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	paramInfo (const std::string &param, Args... args)
	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...

template<typename... Args>
void	mooseError (Args &&... args) const

template<typename... Args>
void	mooseWarning (Args &&... args) const

template<typename... Args>
void	mooseDeprecated (Args &&... args) const

template<typename... Args>
void	mooseInfo (Args &&... args) const


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 MaterialPropertyStorage &	getMaterialPropertyStorage ()
	Return a reference to the material property storage. More...

const MaterialPropertyStorage &	getBndMaterialPropertyStorage ()

const MaterialPropertyStorage &	getNeighborMaterialPropertyStorage ()


const MooseObjectWarehouse< Indicator > &	getIndicatorWarehouse ()
	Return indicator/marker storage. More...

const MooseObjectWarehouse< InternalSideIndicator > &	getInternalSideIndicatorWarehouse ()

const MooseObjectWarehouse< Marker > &	getMarkerWarehouse ()


bool	needBoundaryMaterialOnSide (BoundaryID bnd_id, THREAD_ID tid)
	These methods are used to determine whether stateful material properties need to be stored on internal sides. More...

bool	needSubdomainMaterialOnSide (SubdomainID subdomain_id, THREAD_ID tid)


const ExecFlagType &	getCurrentExecuteOnFlag () const
	Return/set the current execution flag. More...

void	setCurrentExecuteOnFlag (const ExecFlagType &)

Public Attributes
std::map< std::string, std::vector< dof_id_type > >	_var_dof_map

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< MooseArray< DualReal > >	_ad_zero

std::vector< VariableGradient >	_grad_zero

std::vector< MooseArray< DualRealVectorValue > >	_ad_grad_zero

std::vector< VariableSecond >	_second_zero

std::vector< MooseArray< DualRealTensorValue > >	_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

Protected Member Functions
void	createTagVectors ()
	Create extra tagged vectors and matrices. More...

void	meshChangedHelper (bool intermediate_change=false)
	Helper method to update some or all data after a mesh change. More...

bool	duplicateVariableCheck (const std::string &var_name, const FEType &type, bool is_aux)
	Helper to check for duplicate variable names across systems or within a single system. More...

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< Material >>> &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 ()
	Call when it is possible that the needs for ghosted elements has changed. More...

MooseVariableFEBase &	getVariableHelper (THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type, Moose::VarFieldType expected_var_field_type, SystemBase &nl, SystemBase &aux)
	Helper function called by getVariable that handles the logic for checking whether Variables of the requested type are available. More...

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level)
	Call to register a named section for timing. More...

template<typename T >
T &	declareRestartableData (std::string data_name)
	Declare a piece of data as "restartable". More...

template<typename T >
T &	declareRestartableData (std::string data_name, const T &init_value)
	Declare a piece of data as "restartable" and initialize it. More...

template<typename T >
T &	declareRestartableDataWithContext (std::string data_name, void *context)
	Declare a piece of data as "restartable". More...

template<typename T >
T &	declareRestartableDataWithContext (std::string data_name, const T &init_value, void *context)
	Declare a piece of data as "restartable" and initialize it. More...

template<typename T >
T &	declareRecoverableData (std::string data_name)
	Declare a piece of data as "recoverable". More...

template<typename T >
T &	declareRecoverableData (std::string data_name, const T &init_value)
	Declare a piece of data as "restartable" and initialize it. More...

template<typename T >
T &	declareRestartableDataWithObjectName (std::string data_name, std::string object_name)
	Declare a piece of data as "restartable". More...

template<typename T >
T &	declareRestartableDataWithObjectNameWithContext (std::string data_name, std::string object_name, void *context)
	Declare a piece of data as "restartable". More...

Protected Attributes
bool	_use_nonlinear

std::shared_ptr< NonlinearSystem >	_nl_sys

MooseMesh &	_mesh

EquationSystems	_eq

bool	_initialized

std::set< TagID >	_fe_vector_tags

std::set< TagID >	_fe_matrix_tags

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

std::shared_ptr< NonlinearSystemBase >	_nl

std::shared_ptr< AuxiliarySystem >	_aux

Moose::CouplingType	_coupling
	Type of variable coupling. More...

std::unique_ptr< CouplingMatrix >	_cm
	Coupling matrix for variables. More...

std::map< std::string, unsigned int >	_subspace_dim

std::vector< std::unique_ptr< Assembly > >	_assembly

MooseObjectWarehouse< Function >	_functions
	functions More...

MooseObjectWarehouseBase< Distribution >	_distributions
	distributions More...

ExecuteMooseObjectWarehouse< Sampler >	_samplers
	Samplers. More...

MooseObjectWarehouse< KernelBase >	_nonlocal_kernels
	nonlocal kernels More...

MooseObjectWarehouse< IntegratedBCBase >	_nonlocal_integrated_bcs
	nonlocal integrated_bcs More...

MaterialPropertyStorage &	_material_props

MaterialPropertyStorage &	_bnd_material_props

MaterialPropertyStorage &	_neighbor_material_props

std::vector< std::shared_ptr< MaterialData > >	_material_data

std::vector< std::shared_ptr< MaterialData > >	_bnd_material_data

std::vector< std::shared_ptr< MaterialData > >	_neighbor_material_data

MooseObjectWarehouse< Marker >	_markers

PostprocessorData	_pps_data

VectorPostprocessorData	_vpps_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...

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< MeshChangedInterface * >	_notify_when_mesh_changes
	Objects to be notified when the mesh changes. 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

bool	_reinit_displaced_elem

bool	_reinit_displaced_face

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

std::unique_ptr< Resurrector >	_resurrector
	Object responsible for restart (read/write) 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	_has_nonlocal_coupling
	Indicates if nonlocal coupling is required/exists. More...

bool	_calculate_jacobian_in_uo

std::vector< std::vector< MooseVariableFEBase * > >	_uo_jacobian_moose_vars

SolverParams	_solver_params

bool	_kernel_coverage_check
	Determines whether a check to verify an active kernel on every subdomain. More...

bool	_material_coverage_check
	Determines whether a check to verify an active material on every subdomain. More...

unsigned int	_max_qps
	Maximum number of quadrature points used in the problem. More...

unsigned int	_max_shape_funcs
	Maximum number of shape functions on any element in the problem. More...

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

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

std::shared_ptr< LineSearch >	_line_search

std::unique_ptr< ConstElemRange >	_evaluable_local_elem_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...

std::map< TagName, TagID >	_vector_tag_name_to_tag_id
	The currently declared tags. More...

std::map< TagID, TagName >	_vector_tag_id_to_tag_name
	Reverse map. 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...

CouplingMatrix	_nonlocal_cm

std::map< SubdomainID, Moose::CoordinateSystemType >	_coord_sys
	nonlocal coupling matrix; 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< MooseVariableFEBase * > >	_active_elemental_moose_variables
	This is the set of MooseVariableFEBases 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< unsigned int > >	_active_material_property_ids
	Set of material property ids that determine whether materials get reinited. 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	_requires_nonlocal_coupling
	nonlocal coupling requirement flag More...

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

unsigned int	_rz_coord_axis
	Storage for RZ axis selection. More...

bool	_currently_computing_jacobian
	Flag to determine whether the problem is currently computing Jacobian. More...

bool	_computing_nonlinear_residual
	Whether residual being evaulated is non-linear. 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...

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 InputParameters &	_pars
	Parameters of this object, references the InputParameters stored in the InputParametersWarehouse. More...

MooseApp &	_app
	The MooseApp this object is associated with. More...

const std::string &	_type
	The type of this object (the Class name) More...

const std::string &	_name
	The name of this object, reference to value stored in InputParameters. More...

const bool &	_enabled
	Reference to the "enable" InputParaemters, used by Controls for toggling on/off MooseObjects. More...

const InputParameters *	_pg_params
	Params. More...

PerfGraph &	_perf_graph
	The performance graph to add to. More...

std::string	_prefix
	A prefix to use for all sections. More...


InitialConditionWarehouse	_ics

MooseObjectWarehouseBase< ScalarInitialCondition >	_scalar_ics


MaterialWarehouse	_residual_materials

MaterialWarehouse	_jacobian_materials

MaterialWarehouse	_discrete_materials

MaterialWarehouse	_all_materials


MooseObjectWarehouse< Indicator >	_indicators

MooseObjectWarehouse< InternalSideIndicator >	_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

Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.

Definition at line 25 of file FEProblem.h.

Constructor & Destructor Documentation

◆ FEProblem()

FEProblem::FEProblem ( const InputParameters & parameters )

Definition at line 28 of file FEProblem.C.

   : FEProblemBase(parameters),
     _use_nonlinear(getParam<bool>("use_nonlinear")),
     _nl_sys(_use_nonlinear ? (std::make_shared<NonlinearSystem>(*this, "nl0"))
                            : (std::make_shared<MooseEigenSystem>(*this, "eigen0")))
 {
   _nl = _nl_sys;
   _aux = std::make_shared<AuxiliarySystem>(*this, "aux0");
 
   newAssemblyArray(*_nl_sys);
 
   initNullSpaceVectors(parameters, *_nl_sys);
 
   _eq.parameters.set<FEProblem *>("_fe_problem") = this;
 
   // Create extra vectors and matrices if any
   createTagVectors();
 }

Member Function Documentation

◆ _setCLIOption()

void Problem::_setCLIOption ( )

inlineinherited

For Internal Use.

Definition at line 36 of file Problem.h.

36 { _cli_option_found = true; }

Problem::_cli_option_found

bool _cli_option_found

True if the CLI option is found.

Definition: Problem.h:47

◆ adaptivity()

Adaptivity& FEProblemBase::adaptivity ( )

inlineinherited

Definition at line 1254 of file FEProblemBase.h.

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

1254 { return _adaptivity; }

FEProblemBase::_adaptivity

Adaptivity _adaptivity

Definition: FEProblemBase.h:1769

◆ adaptMesh()

bool FEProblemBase::adaptMesh ( )

virtualinherited

Returns: Whether or not the mesh was changed

Reimplemented in DumpObjectsProblem.

Definition at line 5043 of file FEProblemBase.C.

Referenced by Steady::execute(), and Transient::incrementStepOrReject().

 {
   // reset cycle counter
   _cycles_completed = 0;
 
   if (!_adaptivity.isAdaptivityDue())
     return false;
 
   TIME_SECTION(_adapt_mesh_timer);
 
   unsigned int cycles_per_step = _adaptivity.getCyclesPerStep();
 
   bool mesh_changed = false;
 
   for (unsigned int i = 0; i < cycles_per_step; ++i)
   {
     _console << "Adaptivity step " << i + 1 << " of " << cycles_per_step << '\n';
 
     // Markers were already computed once by Executioner
     if (_adaptivity.getRecomputeMarkersFlag() && i > 0)
       computeMarkers();
 
     if (_adaptivity.adaptMesh())
     {
       mesh_changed = true;
 
       meshChangedHelper(true); // This may be an intermediate change
       _cycles_completed++;
     }
     else
     {
       _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)
     _eq.reinit_systems();
 
   return mesh_changed;
 }

◆ addADJacobianMaterial()

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

virtualinherited

Definition at line 2370 of file FEProblemBase.C.

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

◆ addADResidualMaterial()

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

virtualinherited

Definition at line 2362 of file FEProblemBase.C.

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

◆ addAuxKernel()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 2041 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addAuxKernel().

 {
   if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
   {
     parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
     parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
     parameters.set<SystemBase *>("_nl_sys") = &_displaced_problem->nlSys();
     if (!parameters.get<std::vector<BoundaryName>>("boundary").empty())
       _reinit_displaced_face = true;
     else
       _reinit_displaced_elem = true;
   }
   else
   {
     if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
     {
       // We allow AuxKernels 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 AuxKernel.
       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();
     parameters.set<SystemBase *>("_nl_sys") = _nl.get();
   }
 
   _aux->addKernel(kernel_name, name, parameters);
 }

◆ addAuxScalarKernel()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 2076 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addAuxScalarKernel().

 {
   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();
   }
 
   _aux->addScalarKernel(kernel_name, name, parameters);
 }

◆ addAuxScalarVariable()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 2023 of file FEProblemBase.C.

 {
   if (order > _max_scalar_order)
     _max_scalar_order = order;
 
   FEType type(order, SCALAR);
   if (duplicateVariableCheck(var_name, type, /* is_aux = */ true))
     return;
 
   _aux->addScalarVariable(var_name, order, scale_factor, active_subdomains);
   if (_displaced_problem)
     _displaced_problem->addAuxScalarVariable(var_name, order, scale_factor, active_subdomains);
 }

◆ addAuxVariable()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 2010 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addAuxVariable().

 {
   if (duplicateVariableCheck(var_name, type, /* is_aux = */ true))
     return;
 
   _aux->addVariable(var_name, type, 1.0, active_subdomains);
   if (_displaced_problem)
     _displaced_problem->addAuxVariable(var_name, type, active_subdomains);
 }

◆ addBoundaryCondition()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 1944 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addBoundaryCondition().

 {
   if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
   {
     parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
     parameters.set<SystemBase *>("_sys") = &_displaced_problem->nlSys();
     const auto & disp_names = _displaced_problem->getDisplacementVarNames();
     parameters.set<std::vector<VariableName>>("displacements") =
         std::vector<VariableName>(disp_names.begin(), disp_names.end());
     _reinit_displaced_face = 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;
     parameters.set<SystemBase *>("_sys") = _nl.get();
   }
 
   _nl->addBoundaryCondition(bc_name, name, parameters);
 }

◆ addCachedJacobian()

void FEProblemBase::addCachedJacobian ( THREAD_ID tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1273 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::enforceNodalConstraintsJacobian(), and ComputeJacobianThread::postElement().

 {
   _assembly[tid]->addCachedJacobian();
   if (_displaced_problem)
     _displaced_problem->addCachedJacobian(tid);
 }

◆ addCachedResidual()

void FEProblemBase::addCachedResidual ( THREAD_ID tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1182 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::constraintResiduals(), ComputeNodalKernelBcsThread::onNode(), ComputeNodalKernelsThread::onNode(), and ComputeResidualThread::postElement().

 {
   _assembly[tid]->addCachedResiduals();
 
   if (_displaced_problem)
     _displaced_problem->addCachedResidual(tid);
 }

◆ addCachedResidualDirectly()

void FEProblemBase::addCachedResidualDirectly	(	NumericVector< Number > &	residual,
		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 1191 of file FEProblemBase.C.

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

 {
   _assembly[tid]->addCachedResidual(residual, _nl->timeVectorTag());
   _assembly[tid]->addCachedResidual(residual, _nl->nonTimeVectorTag());
 
   if (_displaced_problem)
     _displaced_problem->addCachedResidualDirectly(residual, tid);
 }

◆ addConstraint()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 1977 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addConstraint().

 {
   _has_constraints = true;
 
   if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
   {
     parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
     parameters.set<SystemBase *>("_sys") = &_displaced_problem->nlSys();
     _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.get();
   }
 
   // Check that "variable" is in the NonlinearSystem.
   if (!_nl->hasVariable(parameters.get<NonlinearVariableName>("variable")))
     mooseError(name,
                ": Cannot add Constraint for variable ",
                parameters.get<NonlinearVariableName>("variable"),
                ", it is not a nonlinear variable!");
 
   _nl->addConstraint(c_name, name, parameters);
 }

◆ addDamper()

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

virtualinherited

Definition at line 3293 of file FEProblemBase.C.

 {
   parameters.set<SubProblem *>("_subproblem") = this;
   parameters.set<SystemBase *>("_sys") = _nl.get();
 
   _has_dampers = true;
   _nl->addDamper(damper_name, name, parameters);
 }

◆ addDGKernel()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 2137 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addDGKernel().

 {
   if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
   {
     parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
     parameters.set<SystemBase *>("_sys") = &_displaced_problem->nlSys();
     _reinit_displaced_face = 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.get();
   }
 
   _nl->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

Reimplemented in DumpObjectsProblem.

Definition at line 2105 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addDiracKernel().

 {
   if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
   {
     parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
     parameters.set<SystemBase *>("_sys") = &_displaced_problem->nlSys();
     _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.get();
   }
 
   _nl->addDiracKernel(kernel_name, name, parameters);
 }

◆ addDisplacedProblem()

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

virtualinherited

Definition at line 4930 of file FEProblemBase.C.

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

◆ addDistribution()

void FEProblemBase::addDistribution	(	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 1748 of file FEProblemBase.C.

 {
   parameters.set<std::string>("type") = type;
   std::shared_ptr<Distribution> dist = _factory.create<Distribution>(type, name, parameters);
   _distributions.addObject(dist);
 }

◆ addExtraVectors()

void FEProblemBase::addExtraVectors ( )

virtualinherited

A place to add extra vectors to the simulation.

It is called early during initialSetup.

Definition at line 552 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

 {
   _nl->addExtraVectors();
   _aux->addExtraVectors();
 }

◆ addFunction()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 1669 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addFunction(), and FEProblemBase::getFunction().

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

◆ 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 1352 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 1345 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);
 }

◆ addIndicator()

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

inherited

Definition at line 3311 of file FEProblemBase.C.

 {
   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);
 
     std::shared_ptr<InternalSideIndicator> isi =
         std::dynamic_pointer_cast<InternalSideIndicator>(indicator);
     if (isi)
       _internal_side_indicators.addObject(isi, tid);
     else
       _indicators.addObject(indicator, tid);
   }
 }

◆ addInitialCondition()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 2203 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addInitialCondition().

 {
 
   // before we start to mess with the initial condition, we need to check parameters for errors.
   parameters.checkParams(name);
 
   parameters.set<SubProblem *>("_subproblem") = this;
 
   const std::string & var_name = parameters.get<VariableName>("variable");
   // field IC
   if (hasVariable(var_name))
   {
     for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
     {
       MooseVariableFEBase & var = getVariable(
           tid, var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY);
       parameters.set<SystemBase *>("_sys") = &var.sys();
       std::shared_ptr<InitialConditionBase> ic;
       if (dynamic_cast<MooseVariable *>(&var))
         ic = _factory.create<InitialCondition>(ic_name, name, parameters, tid);
       else if (dynamic_cast<VectorMooseVariable *>(&var))
         ic = _factory.create<VectorInitialCondition>(ic_name, name, parameters, tid);
       else
         mooseError("Your FE variable in initial condition ",
                    name,
                    " must be either of scalar or vector type");
       _ics.addObject(ic, tid);
     }
   }
 
   // scalar IC
   else if (hasScalarVariable(var_name))
   {
     MooseVariableScalar & var = getScalarVariable(0, var_name);
     parameters.set<SystemBase *>("_sys") = &var.sys();
     std::shared_ptr<ScalarInitialCondition> ic =
         _factory.create<ScalarInitialCondition>(ic_name, name, parameters);
     _scalar_ics.addObject(ic);
   }
 
   else
     mooseError(
         "Variable '", var_name, "' requested in initial condition '", name, "' does not exist.");
 }

◆ addInterfaceKernel()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 2171 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addInterfaceKernel().

 {
   if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
   {
     parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
     parameters.set<SystemBase *>("_sys") = &_displaced_problem->nlSys();
     _reinit_displaced_face = 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.get();
   }
 
   _nl->addInterfaceKernel(interface_kernel_name, name, parameters);
 
   _has_internal_edge_residual_objects = true;
 }

◆ addJacobian()

void FEProblemBase::addJacobian ( THREAD_ID tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1217 of file FEProblemBase.C.

Referenced by ComputeDiracThread::postElement().

 {
   _assembly[tid]->addJacobian();
   if (_has_nonlocal_coupling)
     _assembly[tid]->addJacobianNonlocal();
   if (_displaced_problem)
   {
     _displaced_problem->addJacobian(tid);
     if (_has_nonlocal_coupling)
       _displaced_problem->addJacobianNonlocal(tid);
   }
 }

◆ addJacobianBlock()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 1281 of file FEProblemBase.C.

Referenced by ComputeJacobianBlocksThread::postElement().

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

◆ addJacobianNeighbor() [1/2]

void FEProblemBase::addJacobianNeighbor ( THREAD_ID tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1231 of file FEProblemBase.C.

Referenced by ComputeJacobianThread::onInterface(), and ComputeJacobianThread::onInternalSide().

 {
   _assembly[tid]->addJacobianNeighbor();
   if (_displaced_problem)
     _displaced_problem->addJacobianNeighbor(tid);
 }

◆ addJacobianNeighbor() [2/2]

void FEProblemBase::addJacobianNeighbor	(	SparseMatrix< 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,
		THREAD_ID	tid
	)

overridevirtualinherited

Implements SubProblem.

Definition at line 1311 of file FEProblemBase.C.

 {
   _assembly[tid]->addJacobianNeighbor(
       jacobian, ivar, jvar, dof_map, dof_indices, neighbor_dof_indices);
   if (_displaced_problem)
     _displaced_problem->addJacobianNeighbor(
         jacobian, ivar, jvar, dof_map, dof_indices, neighbor_dof_indices, tid);
 }

◆ addJacobianOffDiagScalar()

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

virtualinherited

Definition at line 1245 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians().

 {
   _assembly[tid]->addJacobianOffDiagScalar(ivar);
 }

◆ addJacobianScalar()

void FEProblemBase::addJacobianScalar ( THREAD_ID tid = 0 )

virtualinherited

Definition at line 1239 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians().

 {
   _assembly[tid]->addJacobianScalar();
 }

◆ addKernel()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 1853 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addKernel().

 {
   if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
   {
     parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
     parameters.set<SystemBase *>("_sys") = &_displaced_problem->nlSys();
     const auto & disp_names = _displaced_problem->getDisplacementVarNames();
     parameters.set<std::vector<VariableName>>("displacements") =
         std::vector<VariableName>(disp_names.begin(), disp_names.end());
     _reinit_displaced_elem = true;
   }
   else
   {
     if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
     {
       // We allow Kernels 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 Kernel.
       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.get();
   }
 
   _nl->addKernel(kernel_name, name, parameters);
 }

◆ addLineSearch()

void FEProblem::addLineSearch ( const InputParameters & )

overridevirtual

add a MOOSE line search

Reimplemented from FEProblemBase.

Definition at line 57 of file FEProblem.C.

 {
   MooseEnum line_search = parameters.get<MooseEnum>("line_search");
   Moose::LineSearchType enum_line_search = Moose::stringToEnum<Moose::LineSearchType>(line_search);
   if (enum_line_search == Moose::LS_CONTACT)
   {
 #ifdef LIBMESH_HAVE_PETSC
 #if PETSC_VERSION_LESS_THAN(3, 6, 0)
     mooseError("Shell line searches only became available in Petsc in version 3.6.0!");
 #else
     InputParameters ls_params = _factory.getValidParams("PetscContactLineSearch");
 
     bool affect_ltol = parameters.isParamValid("contact_line_search_ltol");
     ls_params.set<bool>("affect_ltol") = affect_ltol;
     ls_params.set<unsigned>("allowed_lambda_cuts") =
         parameters.get<unsigned>("contact_line_search_allowed_lambda_cuts");
     ls_params.set<Real>("contact_ltol") = affect_ltol
                                               ? parameters.get<Real>("contact_line_search_ltol")
                                               : parameters.get<Real>("l_tol");
     ls_params.set<FEProblem *>("_fe_problem") = this;
 
     _line_search =
         _factory.create<LineSearch>("PetscContactLineSearch", "contact_line_search", ls_params);
 #endif
 #else
     mooseError("Currently contact line search requires use of Petsc.");
 #endif
   }
 }

◆ addMarker()

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

virtualinherited

Definition at line 3352 of file FEProblemBase.C.

 {
   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);
     _markers.addObject(marker, tid);
   }
 }

◆ addMaterial()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 2354 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addMaterial().

 {
   addMaterialHelper({&_residual_materials, &_jacobian_materials}, mat_name, name, parameters);
 }

◆ addMaterialHelper()

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

virtualinherited

Definition at line 2378 of file FEProblemBase.C.

Referenced by FEProblemBase::addADJacobianMaterial(), FEProblemBase::addADResidualMaterial(), and FEProblemBase::addMaterial().

 {
   if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
   {
     parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
     _reinit_displaced_elem = 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 Material object
     std::shared_ptr<Material> material = _factory.create<Material>(mat_name, name, parameters, tid);
     bool discrete = !material->getParam<bool>("compute");
 
     // If the object is boundary restricted do not create the neighbor and face objects
     if (material->boundaryRestricted())
     {
       _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
     {
       // 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<Material> face_material =
           _factory.create<Material>(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<Material> neighbor_material =
           _factory.create<Material>(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);
 
       // link parameters of face and neighbor materials
       MooseObjectParameterName name(MooseObjectName("Material", material->name()), "*");
       MooseObjectParameterName face_name(MooseObjectName("Material", face_material->name()), "*");
       MooseObjectParameterName neighbor_name(MooseObjectName("Material", neighbor_material->name()),
                                              "*");
       _app.getInputParameterWarehouse().addControllableParameterConnection(name, face_name, false);
       _app.getInputParameterWarehouse().addControllableParameterConnection(
           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 111 of file SubProblem.C.

Referenced by DisplacedProblem::addMatrixTag(), FEProblemBase::createTagVectors(), NonlinearEigenSystem::NonlinearEigenSystem(), 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);
 }

◆ 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 3386 of file FEProblemBase.C.

 {
   parameters.set<MPI_Comm>("_mpi_comm") = _communicator.get();
   parameters.set<std::shared_ptr<CommandLine>>("_command_line") = _app.commandLine();
 
   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);
 
   multi_app->setupPositions();
 
   _multi_apps.addObject(multi_app);
 
   // Store TranseintMultiApp 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

Reimplemented in DumpObjectsProblem.

Definition at line 1886 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addNodalKernel().

 {
   if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
   {
     parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
     parameters.set<SystemBase *>("_sys") = &_displaced_problem->nlSys();
     _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.get();
   }
   _nl->addNodalKernel(kernel_name, name, parameters);
 }

◆ addOutput()

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

inherited

Adds an Output object.

Definition at line 5816 of file FEProblemBase.C.

 {
   // 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;
   }
 
   // Apply the common parameters
   InputParameters * common = output_warehouse.getCommonParameters();
   if (common)
     parameters.applyParameters(*common, exclude);
 
   // 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);
   output_warehouse.addOutput(output);
 }

◆ addPostprocessor()

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

virtualinherited

Definition at line 2659 of file FEProblemBase.C.

 {
   // Check for name collision
   if (hasUserObject(name))
     mooseError(std::string("A UserObject with the name \"") + name +
                "\" already exists.  You may not add a Postprocessor by the same name.");
 
   addUserObject(pp_name, name, parameters);
   initPostprocessorData(name);
 }

◆ addPredictor()

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

virtualinherited

Definition at line 4338 of file FEProblemBase.C.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector().

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

◆ addResidual()

void FEProblemBase::addResidual ( THREAD_ID tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1142 of file FEProblemBase.C.

Referenced by ComputeDiracThread::postElement().

 {
   _assembly[tid]->addResidual(getVectorTags());
 
   if (_displaced_problem)
     _displaced_problem->addResidual(tid);
 }

◆ addResidualNeighbor()

void FEProblemBase::addResidualNeighbor ( THREAD_ID tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1151 of file FEProblemBase.C.

Referenced by ComputeResidualThread::onInterface(), and ComputeResidualThread::onInternalSide().

 {
   _assembly[tid]->addResidualNeighbor(getVectorTags());
 
   if (_displaced_problem)
     _displaced_problem->addResidualNeighbor(tid);
 }

◆ addResidualScalar()

void FEProblemBase::addResidualScalar ( THREAD_ID tid = 0 )

virtualinherited

Definition at line 1160 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeResidualInternal().

 {
   _assembly[tid]->addResidualScalar(getVectorTags());
 }

◆ addSampler()

void FEProblemBase::addSampler	(	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 1767 of file FEProblemBase.C.

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

◆ addScalarKernel()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 1915 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addScalarKernel().

 {
   if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
   {
     parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
     parameters.set<SystemBase *>("_sys") = &_displaced_problem->nlSys();
   }
   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.get();
   }
 
   _nl->addScalarKernel(kernel_name, name, parameters);
 }

◆ addScalarVariable()

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

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 1835 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addAuxScalarVariable(), and DumpObjectsProblem::addScalarVariable().

 {
   if (order > _max_scalar_order)
     _max_scalar_order = order;
 
   FEType type(order, SCALAR);
   if (duplicateVariableCheck(var_name, type, /* is_aux = */ false))
     return;
 
   _nl->addScalarVariable(var_name, order, scale_factor, active_subdomains);
   if (_displaced_problem)
     _displaced_problem->addScalarVariable(var_name, order, scale_factor, active_subdomains);
 }

◆ addTimeIntegrator()

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

virtualinherited

Definition at line 4322 of file FEProblemBase.C.

Referenced by Transient::setupTimeIntegrator().

 {
   parameters.set<SubProblem *>("_subproblem") = this;
   _aux->addTimeIntegrator(type, name + ":aux", parameters);
   _nl->addTimeIntegrator(type, name, parameters);
   _has_time_integrator = true;
 
   // add vectors to store u_dot, u_dotdot, udot_old and u_dotdot_old if requested by the time
   // integrator
   _aux->addDotVectors();
   _nl->addDotVectors();
 }

◆ addTransfer()

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

virtualinherited

Add a Transfer to the problem.

Definition at line 3654 of file FEProblemBase.C.

 {
   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 Transfers 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 Transfer.
       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();
   }
 
   // Handle the "SAME_AS_MULTIAPP" execute option
   ExecFlagEnum & exec_enum = parameters.set<ExecFlagEnum>("execute_on", true);
   if (exec_enum.contains(EXEC_SAME_AS_MULTIAPP))
   {
     std::shared_ptr<MultiApp> multiapp = getMultiApp(parameters.get<MultiAppName>("multi_app"));
     exec_enum = multiapp->getParam<ExecFlagEnum>("execute_on");
   }
 
   // Create the Transfer objects
   std::shared_ptr<Transfer> transfer = _factory.create<Transfer>(transfer_name, name, parameters);
 
   // Add MultiAppTransfer object
   std::shared_ptr<MultiAppTransfer> multi_app_transfer =
       std::dynamic_pointer_cast<MultiAppTransfer>(transfer);
   if (multi_app_transfer)
   {
     if (multi_app_transfer->direction() == MultiAppTransfer::TO_MULTIAPP)
       _to_multi_app_transfers.addObject(multi_app_transfer);
     else
       _from_multi_app_transfers.addObject(multi_app_transfer);
   }
   else
     _transfers.addObject(transfer);
 }

◆ addUserObject()

void FEProblemBase::addUserObject	(	std::string	user_object_name,
		const std::string &	name,
		InputParameters	parameters
	)

virtualinherited

Definition at line 2687 of file FEProblemBase.C.

Referenced by FEProblemBase::addPostprocessor(), and FEProblemBase::addVectorPostprocessor().

 {
   if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
     parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
   else
   {
     if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
     {
       // We allow UserObjects 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 UserObject.
       if (parameters.have_parameter<bool>("use_displaced_mesh"))
         parameters.set<bool>("use_displaced_mesh") = false;
     }
 
     parameters.set<SubProblem *>("_subproblem") = this;
   }
 
   UserObject * primary = nullptr;
   for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
   {
     // Create the UserObject
     std::shared_ptr<UserObject> user_object =
         _factory.create<UserObject>(user_object_name, name, parameters, tid);
     if (tid == 0)
       primary = user_object.get();
     else
       user_object->setPrimaryThreadCopy(primary);
 
     // TODO: delete this line after apps have been updated to not call getUserObjects
     _all_user_objects.addObject(user_object, tid);
 
     theWarehouse().add(user_object, "UserObject");
 
     // 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<InterfaceUserObject>(user_object);
     auto nuo = std::dynamic_pointer_cast<NodalUserObject>(user_object);
     auto guo = std::dynamic_pointer_cast<GeneralUserObject>(user_object);
     auto tguo = std::dynamic_pointer_cast<ThreadedGeneralUserObject>(user_object);
 
     // Account for displaced mesh use
     if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
     {
       if (euo || nuo)
         _reinit_displaced_elem = true;
       else if (suo || iuo)
         // shouldn't we add isuo
         _reinit_displaced_face = true;
     }
 
     if (guo && !tguo)
       break;
   }
 }

◆ addVariable()

void FEProblemBase::addVariable	(	const std::string &	var_name,
		const FEType &	type,
		Real	scale_factor,
		const std::set< SubdomainID > *const	active_subdomains = `NULL`
	)

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 1821 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addVariable().

 {
   if (duplicateVariableCheck(var_name, type, /* is_aux = */ false))
     return;
 
   _nl->addVariable(var_name, type, scale_factor, active_subdomains);
   if (_displaced_problem)
     _displaced_problem->addVariable(var_name, type, scale_factor, active_subdomains);
 }

◆ addVectorPostprocessor()

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

virtualinherited

Definition at line 2673 of file FEProblemBase.C.

 {
   // Check for name collision
   if (hasUserObject(name))
     mooseError(std::string("A UserObject with the name \"") + name +
                "\" already exists.  You may not add a VectorPostprocessor by the same name.");
 
   addUserObject(pp_name, name, parameters);
   initVectorPostprocessorData(name);
 }

◆ addVectorTag()

TagID SubProblem::addVectorTag ( 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 65 of file SubProblem.C.

Referenced by DisplacedProblem::addVectorTag(), FEProblemBase::createTagVectors(), NonlinearSystemBase::getResidualNonTimeVector(), NonlinearSystemBase::getResidualTimeVector(), NonlinearEigenSystem::NonlinearEigenSystem(), and NonlinearSystemBase::NonlinearSystemBase().

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

◆ advanceMultiApps()

void FEProblemBase::advanceMultiApps ( ExecFlagType type )

inlineinherited

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

Definition at line 940 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 4221 of file FEProblemBase.C.

Referenced by Steady::execute(), Transient::incrementStepOrReject(), NonlinearEigen::init(), TransientMultiApp::setupApp(), ExplicitTVDRK2::solve(), ExplicitRK2::solve(), TransientMultiApp::solveStep(), DT2::step(), NonlinearEigen::takeStep(), and InversePowerMethod::takeStep().

 {
   TIME_SECTION(_advance_state_timer);
 
   _nl->copyOldSolutions();
   _aux->copyOldSolutions();
 
   if (_displaced_problem)
   {
     _displaced_problem->nlSys().copyOldSolutions();
     _displaced_problem->auxSys().copyOldSolutions();
   }
 
   _pps_data.copyValuesBack();
   _vpps_data.copyValuesBack();
 
   if (_material_props.hasStatefulProperties())
     _material_props.shift(*this);
 
   if (_bnd_material_props.hasStatefulProperties())
     _bnd_material_props.shift(*this);
 
   if (_neighbor_material_props.hasStatefulProperties())
     _neighbor_material_props.shift(*this);
 }

◆ 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 4290 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 1954 of file FEProblemBase.h.

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

◆ areCoupled()

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

inherited

Definition at line 4009 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintJacobians().

 {
   return (*_cm)(ivar, jvar);
 }

◆ assembly()

virtual Assembly& FEProblemBase::assembly ( THREAD_ID tid )

inlineoverridevirtualinherited

Implements SubProblem.

Definition at line 330 of file FEProblemBase.h.

Referenced by VectorNodalBC::computeJacobian(), NodalBC::computeJacobian(), NonlinearSystemBase::computeJacobianInternal(), VectorNodalBC::computeOffDiagJacobian(), NodalBC::computeOffDiagJacobian(), NonlinearSystemBase::constraintJacobians(), ComputeBoundaryInitialConditionThread::onNode(), ComputeNodalKernelBCJacobiansThread::onNode(), and ComputeNodalKernelJacobiansThread::onNode().

   {
     mooseAssert(tid < _assembly.size(), "Assembly objects not initialized");
     return *_assembly[tid];
   }

◆ backupMultiApps()

void FEProblemBase::backupMultiApps ( ExecFlagType type )

inherited

Backup the MultiApps associated with the ExecFlagType.

Definition at line 3583 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup(), and PicardSolve::solve().

 {
   const auto & multi_apps = _multi_apps[type].getActiveObjects();
 
   if (multi_apps.size())
   {
     TIME_SECTION(_backup_multi_apps_timer);
 
     _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);
 
     _console << COLOR_CYAN << "Finished Backing Up MultiApps on " << type.name() << "\n"
              << COLOR_DEFAULT << std::endl;
   }
 }

◆ cacheJacobian()

void FEProblemBase::cacheJacobian ( THREAD_ID tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1251 of file FEProblemBase.C.

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

 {
   _assembly[tid]->cacheJacobian();
   if (_has_nonlocal_coupling)
     _assembly[tid]->cacheJacobianNonlocal();
   if (_displaced_problem)
   {
     _displaced_problem->cacheJacobian(tid);
     if (_has_nonlocal_coupling)
       _displaced_problem->cacheJacobianNonlocal(tid);
   }
 }

◆ cacheJacobianNeighbor()

void FEProblemBase::cacheJacobianNeighbor ( THREAD_ID tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1265 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintJacobians().

 {
   _assembly[tid]->cacheJacobianNeighbor();
   if (_displaced_problem)
     _displaced_problem->cacheJacobianNeighbor(tid);
 }

◆ cacheResidual()

void FEProblemBase::cacheResidual ( THREAD_ID tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1166 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintResiduals(), and ComputeResidualThread::postElement().

 {
   _assembly[tid]->cacheResidual();
   if (_displaced_problem)
     _displaced_problem->cacheResidual(tid);
 }

◆ cacheResidualNeighbor()

void FEProblemBase::cacheResidualNeighbor ( THREAD_ID tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1174 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::constraintResiduals().

 {
   _assembly[tid]->cacheResidualNeighbor();
   if (_displaced_problem)
     _displaced_problem->cacheResidualNeighbor(tid);
 }

◆ checkBlockMatProps()

void SubProblem::checkBlockMatProps ( )

virtualinherited

Checks block material properties integrity.

See also: FEProblemBase::checkProblemIntegrity

Definition at line 445 of file SubProblem.C.

Referenced by FEProblemBase::checkProblemIntegrity().

 {
   // Variable for storing the value for ANY_BLOCK_ID/ANY_BOUNDARY_ID
   SubdomainID any_id = Moose::ANY_BLOCK_ID;
 
   // Variable for storing all available blocks/boundaries from the mesh
   std::set<SubdomainID> all_ids(mesh().meshSubdomains());
 
   // 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;
 
     // 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<SubdomainID> 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_block_material_props[id].count(prop_it.second) == 0 &&
             _map_block_material_props[any_id].count(prop_it.second) == 0 &&
             _zero_block_material_props[id].count(prop_it.second) == 0 &&
             _zero_block_material_props[any_id].count(prop_it.second) == 0)
         {
           std::string check_name = restrictionSubdomainCheckName(id);
           if (check_name.empty())
             check_name = std::to_string(id);
           mooseError("Material property '",
                      prop_it.second,
                      "', requested by '",
                      prop_it.first,
                      "' is not defined on block ",
                      check_name);
         }
       }
     }
   }
 }

◆ checkBoundaryMatProps()

void SubProblem::checkBoundaryMatProps ( )

virtualinherited

Checks boundary material properties integrity.

See also: FEProblemBase::checkProblemIntegrity

Definition at line 495 of file SubProblem.C.

Referenced by FEProblemBase::checkProblemIntegrity().

 {
   // Variable for storing the value for ANY_BLOCK_ID/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());
 
   // 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);
           mooseError("Material property '",
                      prop_it.second,
                      "', requested by '",
                      prop_it.first,
                      "' is not defined on boundary ",
                      check_name);
         }
       }
     }
   }
 }

◆ checkCoordinateSystems()

void FEProblemBase::checkCoordinateSystems ( )

protectedinherited

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

Definition at line 5553 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

 {
   for (const auto & elem : _mesh.getMesh().element_ptr_range())
   {
     SubdomainID sid = elem->subdomain_id();
     if (_coord_sys[sid] == Moose::COORD_RZ && elem->dim() == 3)
       mooseError("An RZ coordinate system was requested for subdomain " + Moose::stringify(sid) +
                  " which contains 3D elements.");
     if (_coord_sys[sid] == Moose::COORD_RSPHERICAL && elem->dim() > 1)
       mooseError("An RSPHERICAL coordinate system was requested for subdomain " +
                  Moose::stringify(sid) + " which contains 2D or 3D elements.");
   }
 }

◆ checkDependMaterialsHelper()

void FEProblemBase::checkDependMaterialsHelper ( const std::map< SubdomainID, std::vector< std::shared_ptr< Material >>> & 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 5428 of file FEProblemBase.C.

Referenced by FEProblemBase::checkProblemIntegrity().

 {
   auto & prop_names = _material_props.statefulPropNames();
 
   for (const auto & it : materials_map)
   {
     std::set<std::string> block_depend_props, block_supplied_props;
 
     for (const auto & mat1 : it.second)
     {
       const std::set<std::string> & depend_props = mat1->getRequestedItems();
       block_depend_props.insert(depend_props.begin(), depend_props.end());
 
       auto & alldeps = mat1->getMatPropDependencies(); // includes requested stateful props
       for (auto & dep : alldeps)
       {
         if (prop_names.count(dep) > 0)
           block_depend_props.insert(prop_names.at(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->Material::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());
     block_supplied_props.insert(_zero_block_material_props[Moose::ANY_BLOCK_ID].begin(),
                                 _zero_block_material_props[Moose::ANY_BLOCK_ID].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 " << it.first << ":\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 5344 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.");
       }
     }
   }
 }

◆ checkExceptionAndStopSolve()

void FEProblemBase::checkExceptionAndStopSolve ( )

virtualinherited

Check to see if an exception has occurred on any processor and stop the solve.

Note: Collective on MPI! Must be called simultaneously by all processors!

Also: This will throw a MooseException!

Note: DO NOT CALL THIS IN A THREADED REGION! This is meant to be called just after a threaded section.

Definition at line 4142 of file FEProblemBase.C.

Referenced by FEProblemBase::computeBounds().

 {
   TIME_SECTION(_check_exception_and_stop_solve_timer);
 
   // 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);
 
     // Print the message
     if (_communicator.rank() == 0)
       Moose::err << _exception_message << 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.
     _nl->stopSolve();
 
     // 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 linear convergence check to fail.
     _fail_next_linear_convergence_check = true;
 
     // Repropagate the exception, so it can be caught at a higher level, typically
     // this is NonlinearSystem::computeResidual().
     throw MooseException(_exception_message);
   }
 }

◆ checkLinearConvergence()

MooseLinearConvergenceReason FEProblemBase::checkLinearConvergence	(	std::string &	msg,
		const PetscInt	n,
		const Real	rnorm,
		const Real	rtol,
		const Real	atol,
		const Real	dtol,
		const PetscInt	maxits
	)

virtualinherited

Check for convergence of the linear solution.

Parameters

msg	Error message that gets sent back to the solver
n	Iteration counter
rnorm	Norm of the residual vector
rtol	Relative residual convergence tolerance
atol	Absolute residual convergence tolerance
dtol	Divergence tolerance
maxits	Maximum number of linear iterations allowed

Definition at line 5681 of file FEProblemBase.C.

Referenced by Moose::PetscSupport::petscConverged().

 {
   TIME_SECTION(_check_linear_convergence_timer);
 
   if (_fail_next_linear_convergence_check)
   {
     // Unset the flag
     _fail_next_linear_convergence_check = false;
     return MooseLinearConvergenceReason::DIVERGED_NANORINF;
   }
 
   // We initialize the reason to something that basically means MOOSE
   // has not made a decision on convergence yet.
   MooseLinearConvergenceReason reason = MooseLinearConvergenceReason::ITERATING;
 
   // Get a reference to our Nonlinear System
   NonlinearSystemBase & system = getNonlinearSystemBase();
 
   // If it's the beginning of a new set of iterations, reset
   // last_rnorm, otherwise record the most recent linear residual norm
   // in the NonlinearSystem.
   if (n == 0)
     system._last_rnorm = 1e99;
   else
     system._last_rnorm = rnorm;
 
   // If the linear residual norm is less than the System's linear absolute
   // step tolerance, we consider it to be converged and set the reason as
   // MooseLinearConvergenceReason::CONVERGED_RTOL.
   if (std::abs(rnorm - system._last_rnorm) < system._l_abs_step_tol)
     reason = MooseLinearConvergenceReason::CONVERGED_RTOL;
 
   // If we hit max its, then we consider that converged (rather than
   // KSP_DIVERGED_ITS).
   if (n >= maxits)
     reason = MooseLinearConvergenceReason::CONVERGED_ITS;
 
   // If either of our convergence criteria is met, store the number of linear
   // iterations in the System.
   if (reason == MooseLinearConvergenceReason::CONVERGED_ITS ||
       reason == MooseLinearConvergenceReason::CONVERGED_RTOL)
     system._current_l_its.push_back(static_cast<unsigned int>(n));
 
   return reason;
 }

◆ checkNonlinearConvergence()

MooseNonlinearConvergenceReason FEProblemBase::checkNonlinearConvergence	(	std::string &	msg,
		const PetscInt	it,
		const Real	xnorm,
		const Real	snorm,
		const Real	fnorm,
		const Real	rtol,
		const Real	stol,
		const Real	abstol,
		const PetscInt	nfuncs,
		const PetscInt	max_funcs,
		const PetscBool	force_iteration,
		const Real	initial_residual_before_preset_bcs,
		const Real	div_threshold
	)

virtualinherited

Check for converence of the nonlinear solution.

Parameters

msg	Error message that gets sent back to the solver
it	Iteration counter
xnorm	Norm of the solution vector
snorm	Norm of the change in the solution vector
fnorm	Norm of the residual vector
rtol	Relative residual convergence tolerance
stol	Solution change convergence tolerance
abstol	Absolute residual convergence tolerance
nfuncs	Number of function evaluations
max_funcs	Maximum Number of function evaluations
initial_residual_before_preset_bcs	Residual norm prior to imposition of PresetBC values on solution vector
div_threshold	Maximum value of residual before triggering divergence check

Definition at line 5600 of file FEProblemBase.C.

Referenced by Moose::PetscSupport::petscNonlinearConverged().

 {
   TIME_SECTION(_check_nonlinear_convergence_timer);
 
   NonlinearSystemBase & system = getNonlinearSystemBase();
   MooseNonlinearConvergenceReason reason = MooseNonlinearConvergenceReason::ITERATING;
 
   // This is the first residual before any iterations have been done,
   // but after PresetBCs (if any) have been imposed on the solution
   // vector.  We save it, and use it to detect convergence if
   // compute_initial_residual_before_preset_bcs=false.
   if (it == 0)
     system._initial_residual_after_preset_bcs = fnorm;
 
   std::ostringstream oss;
   if (fnorm != fnorm)
   {
     oss << "Failed to converge, function norm is NaN\n";
     reason = MooseNonlinearConvergenceReason::DIVERGED_FNORM_NAN;
   }
   else if (fnorm < abstol && (it || !force_iteration))
   {
     oss << "Converged due to function norm " << fnorm << " < " << abstol << '\n';
     reason = MooseNonlinearConvergenceReason::CONVERGED_FNORM_ABS;
   }
   else if (nfuncs >= max_funcs)
   {
     oss << "Exceeded maximum number of function evaluations: " << nfuncs << " > " << max_funcs
         << '\n';
     reason = MooseNonlinearConvergenceReason::DIVERGED_FUNCTION_COUNT;
   }
   else if (it && fnorm > system._last_nl_rnorm && fnorm >= div_threshold)
   {
     oss << "Nonlinear solve was blowing up!\n";
     reason = MooseNonlinearConvergenceReason::DIVERGED_LINE_SEARCH;
   }
 
   if (it && reason == MooseNonlinearConvergenceReason::ITERATING)
   {
     // If compute_initial_residual_before_preset_bcs==false, then use the
     // first residual computed by Petsc to determine convergence.
     Real the_residual = system._compute_initial_residual_before_preset_bcs
                             ? initial_residual_before_preset_bcs
                             : system._initial_residual_after_preset_bcs;
     if (fnorm <= the_residual * rtol)
     {
       oss << "Converged due to function norm " << fnorm << " < "
           << " (relative tolerance)\n";
       reason = MooseNonlinearConvergenceReason::CONVERGED_FNORM_RELATIVE;
     }
     else if (snorm < stol * xnorm)
     {
       oss << "Converged due to small update length: " << snorm << " < " << stol << " * " << xnorm
           << '\n';
       reason = MooseNonlinearConvergenceReason::CONVERGED_SNORM_RELATIVE;
     }
   }
 
   system._last_nl_rnorm = fnorm;
   system._current_nl_its = static_cast<unsigned int>(it);
 
   msg = oss.str();
   if (_app.multiAppLevel() > 0)
     MooseUtils::indentMessage(_app.name(), msg);
 
   return reason;
 }

◆ checkNonlocalCoupling()

void FEProblemBase::checkNonlocalCoupling ( )

inherited

Returns: Flag indicating nonlocal coupling exists or not.

Definition at line 953 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup().

 {
   for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++)
   {
     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()

virtual bool SubProblem::checkNonlocalCouplingRequirement ( )

inlinevirtualinherited

Definition at line 69 of file SubProblem.h.

Referenced by Assembly::addCachedJacobian(), ComputeFullJacobianThread::computeFaceJacobian(), ComputeJacobianThread::computeFaceJacobian(), ComputeFullJacobianThread::computeJacobian(), ComputeJacobianThread::computeJacobian(), and SystemBase::prepareFace().

69 { return _requires_nonlocal_coupling; }

SubProblem::_requires_nonlocal_coupling

bool _requires_nonlocal_coupling

nonlocal coupling requirement flag

Definition: SubProblem.h:638

◆ 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

Reimplemented in EigenProblem.

Definition at line 5237 of file FEProblemBase.C.

Referenced by EigenProblem::checkProblemIntegrity().

 {
   TIME_SECTION(_check_problem_integrity_timer);
 
   // Check for unsatisfied actions
   const std::set<SubdomainID> & mesh_subdomains = _mesh.meshSubdomains();
 
   // Check kernel coverage of subdomains (blocks) in the mesh
   if (!_skip_nl_system_check && _solve && _kernel_coverage_check)
     _nl->checkKernelCoverage(mesh_subdomains);
 
   // Check materials
   {
 #ifdef LIBMESH_ENABLE_AMR
     if (_adaptivity.isOn() &&
         (_material_props.hasStatefulProperties() || _bnd_material_props.hasStatefulProperties() ||
          _neighbor_material_props.hasStatefulProperties()))
     {
       _console << "Using EXPERIMENTAL Stateful Material Property projection with Adaptivity!\n";
 
       if (n_processors() > 1)
       {
         if (_mesh.uniformRefineLevel() > 0 && _mesh.getMesh().skip_partitioning() == false)
           mooseError("This simulation is using uniform refinement on the mesh, with stateful "
                      "properties and adaptivity. "
                      "You must skip partitioning to run this case:\nMesh/skip_partitioning=true");
 
         _console << "\nWarning! Mesh re-partitioning is disabled while using stateful material "
                     "properties!  This can lead to large load imbalances and degraded "
                     "performance!!\n\n";
         _mesh.getMesh().skip_partitioning(true);
 
         _mesh.errorIfDistributedMesh("StatefulMaterials + Adaptivity");
 
         if (_displaced_problem)
           _displaced_problem->mesh().getMesh().skip_partitioning(true);
       }
     }
 #endif
 
     std::set<SubdomainID> local_mesh_subs(mesh_subdomains);
 
     if (_material_coverage_check)
     {
       bool check_material_coverage = false;
       std::set<SubdomainID> ids = 

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ FEProblem()

Member Function Documentation

◆ _setCLIOption()

◆ adaptivity()

◆ adaptMesh()

◆ addADJacobianMaterial()

◆ addADResidualMaterial()

◆ addAuxKernel()

◆ addAuxScalarKernel()

◆ addAuxScalarVariable()

◆ addAuxVariable()

◆ addBoundaryCondition()

◆ addCachedJacobian()

◆ addCachedResidual()

◆ addCachedResidualDirectly()

◆ addConstraint()

◆ addDamper()

◆ addDGKernel()

◆ addDiracKernel()

◆ addDisplacedProblem()

◆ addDistribution()

◆ addExtraVectors()

◆ addFunction()

◆ addGhostedBoundary()

◆ addGhostedElem()

◆ addIndicator()

◆ addInitialCondition()

◆ addInterfaceKernel()

◆ addJacobian()

◆ addJacobianBlock()

◆ addJacobianNeighbor() [1/2]

◆ addJacobianNeighbor() [2/2]

◆ addJacobianOffDiagScalar()

◆ addJacobianScalar()

◆ addKernel()

◆ addLineSearch()

◆ addMarker()

◆ addMaterial()

◆ addMaterialHelper()

◆ addMatrixTag()

◆ addMultiApp()

◆ addNodalKernel()

◆ addOutput()

◆ addPostprocessor()

◆ addPredictor()

◆ addResidual()

◆ addResidualNeighbor()

◆ addResidualScalar()

◆ addSampler()

◆ addScalarKernel()

◆ addScalarVariable()

◆ addTimeIntegrator()

◆ addTransfer()

◆ addUserObject()

◆ addVariable()

◆ addVectorPostprocessor()

◆ addVectorTag()

◆ advanceMultiApps()

◆ advanceState()

◆ allowOutput() [1/2]

◆ allowOutput() [2/2]

◆ areCoupled()

◆ assembly()

◆ backupMultiApps()

◆ cacheJacobian()

◆ cacheJacobianNeighbor()

◆ cacheResidual()

◆ cacheResidualNeighbor()

◆ checkBlockMatProps()

◆ checkBoundaryMatProps()

◆ checkCoordinateSystems()

◆ checkDependMaterialsHelper()

◆ checkDisplacementOrders()

◆ checkExceptionAndStopSolve()