FEProblem Class Reference

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 (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	hasMultiApps () const
	Returns whether or not the current simulation has any multiapps. More...
bool	hasMultiApp (const std::string &name) const
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	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 &	getComputeMaterialWarehouse () 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	setUsingADFlag (bool using_ad)
	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	usingAD () 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...
virtual bool	checkNonlocalCouplingRequirement ()
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 bool	currentlyComputingJacobian () const
	Returns true if the problem is in the process of computing Jacobian. More...
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)
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< ADReal > >	_ad_zero
std::vector< VariableGradient >	_grad_zero
std::vector< MooseArray< ADRealGradient > >	_ad_grad_zero
std::vector< VariableSecond >	_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
	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...
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	_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	_materials
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.

{ _cli_option_found = true; }

adaptivity()

Adaptivity& FEProblemBase::adaptivity ( )

inlineinherited

Definition at line 1247 of file FEProblemBase.h.

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

{ return _adaptivity; }

adaptMesh()

bool FEProblemBase::adaptMesh ( )

virtualinherited

Returns

Whether or not the mesh was changed

Reimplemented in DumpObjectsProblem.

Definition at line 5066 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 2351 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 2343 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 2022 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addAuxKernel().

{
  if (_displaced_problem != NULL && 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 == NULL && 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 2057 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addAuxScalarKernel().

{
  if (_displaced_problem != NULL && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
  }
  else
  {
    if (_displaced_problem == NULL && 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 2004 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 1991 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 1928 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addBoundaryCondition().

{
  if (_displaced_problem != NULL && 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 == NULL && 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 1260 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 1169 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 1178 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 1958 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addConstraint().

{
  _has_constraints = true;

  if (_displaced_problem != NULL && 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 3335 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 2118 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addDGKernel().

{
  if (_displaced_problem != NULL && 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 == NULL && 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 2086 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addDiracKernel().

{
  if (_displaced_problem != NULL && 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 == NULL && 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 4953 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 1735 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 546 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 1656 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 1339 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 1332 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 3353 of file FEProblemBase.C.

{
  if (_displaced_problem != NULL && 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 == NULL && 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 2184 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 2152 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addInterfaceKernel().

{
  if (_displaced_problem != NULL && 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 == NULL && 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 1204 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 1268 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 1218 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 1298 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 1232 of file FEProblemBase.C.

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians().

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

addJacobianScalar()

void FEProblemBase::addJacobianScalar ( THREAD_ID  tid = 0 )

virtualinherited

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

Referenced by DumpObjectsProblem::addKernel().

{
  if (_displaced_problem != NULL && 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 == NULL && 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 3394 of file FEProblemBase.C.

{
  if (_displaced_problem != NULL && 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 == NULL && 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 2335 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addMaterial().

{
  addMaterialHelper(_materials, mat_name, name, parameters);
}

addMaterialHelper()

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

virtualinherited

Definition at line 2359 of file FEProblemBase.C.

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

{
  if (_displaced_problem != NULL && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    _reinit_displaced_elem = true;
  }
  else
  {
    if (_displaced_problem == NULL && 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
        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
        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 101 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 3428 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 != NULL && 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 == NULL && 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 1870 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addNodalKernel().

{
  if (_displaced_problem != NULL && 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 == NULL && 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 5838 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 != NULL)
    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 2710 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 4365 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 1129 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 1138 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 1147 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 1754 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 1899 of file FEProblemBase.C.

Referenced by DumpObjectsProblem::addScalarKernel().

{
  if (_displaced_problem != NULL && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->nlSys();
  }
  else
  {
    if (_displaced_problem == NULL && 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 1822 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 4349 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 3682 of file FEProblemBase.C.

{
  if (_displaced_problem != NULL && 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 == NULL && 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 2738 of file FEProblemBase.C.

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

{
  if (_displaced_problem != NULL && parameters.get<bool>("use_displaced_mesh"))
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
  else
  {
    if (_displaced_problem == NULL && 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 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 != NULL && parameters.get<bool>("use_displaced_mesh"))
    {
      if (euo || nuo)
        _reinit_displaced_elem = true;
      else if (suo)
        _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 1808 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 2724 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 55 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 933 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 4248 of file FEProblemBase.C.

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

{
  TIME_SECTION(_advance_state_timer);

  _nl->copyOldSolutions();
  _aux->copyOldSolutions();

  if (_displaced_problem != NULL)
  {
    _displaced_problem->nlSys().copyOldSolutions();
    _displaced_problem->auxSys().copyOldSolutions();
  }

  _pps_data.copyValuesBack();
  _vpps_data.copyValuesBack();

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

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

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

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 4317 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 1940 of file FEProblemBase.h.

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

areCoupled()

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

inherited

Definition at line 4036 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 328 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 3613 of file FEProblemBase.C.

Referenced by FEProblemBase::initialSetup(), and Transient::takeStep().

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

  if (multi_apps.size())
  {
    TIME_SECTION(_backup_multi_apps_timer);

    _console << COLOR_CYAN << "\nBacking Up MultiApps" << COLOR_DEFAULT << std::endl;

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

    _console << "Waiting For Other Processors To Finish" << std::endl;
    MooseUtils::parallelBarrierNotify(_communicator, _parallel_barrier_messaging);

    _console << COLOR_CYAN << "Finished Backing Up MultiApps\n" << COLOR_DEFAULT << std::endl;
  }
}

cacheJacobian()

void FEProblemBase::cacheJacobian ( THREAD_ID  tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 1238 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 1252 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 1153 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 1161 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 435 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 485 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 5576 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 5451 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 5367 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 4169 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 5704 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 MOOSE_DIVERGED_NANORINF;
  }

  // We initialize the reason to something that basically means MOOSE
  // has not made a decision on convergence yet.
  MooseLinearConvergenceReason reason = MOOSE_LINEAR_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
  // MOOSE_CONVERGED_RTOL.
  if (std::abs(rnorm - system._last_rnorm) < system._l_abs_step_tol)
    reason = MOOSE_CONVERGED_RTOL;

  // If we hit max its, then we consider that converged (rather than
  // KSP_DIVERGED_ITS).
  if (n >= maxits)
    reason = MOOSE_CONVERGED_ITS;

  // If either of our convergence criteria is met, store the number of linear
  // iterations in the System.
  if (reason == MOOSE_CONVERGED_ITS || reason == MOOSE_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 5623 of file FEProblemBase.C.

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

{
  TIME_SECTION(_check_nonlinear_convergence_timer);

  NonlinearSystemBase & system = getNonlinearSystemBase();
  MooseNonlinearConvergenceReason reason = MOOSE_NONLINEAR_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 = MOOSE_DIVERGED_FNORM_NAN;
  }
  else if (fnorm < abstol && (it || !force_iteration))
  {
    oss << "Converged due to function norm " << fnorm << " < " << abstol << '\n';
    reason = MOOSE_CONVERGED_FNORM_ABS;
  }
  else if (nfuncs >= max_funcs)
  {
    oss << "Exceeded maximum number of function evaluations: " << nfuncs << " > " << max_funcs
        << '\n';
    reason = MOOSE_DIVERGED_FUNCTION_COUNT;
  }
  else if (it && fnorm > system._last_nl_rnorm && fnorm >= div_threshold)
  {
    oss << "Nonlinear solve was blowing up!\n";
    reason = MOOSE_DIVERGED_LINE_SEARCH;
  }

  if (it && !reason)
  {
    // 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 = MOOSE_CONVERGED_FNORM_RELATIVE;
    }
    else if (snorm < stol * xnorm)
    {
      oss << "Converged due to small update length: " << snorm << " < " << stol << " * " << xnorm
          << '\n';
      reason = MOOSE_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 940 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 62 of file SubProblem.h.

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

{ return _requires_nonlocal_coupling; }

checkProblemIntegrity()

void FEProblemBase::checkProblemIntegrity ( )

virtualinherited

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

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

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

unsigned int is necessary to print SubdomainIDs in the statement below

Reimplemented in EigenProblem.

Definition at line 5260 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 = _all_materials.getActiveBlocks();
      for (const auto & id : ids)
      {
        local_mesh_subs.erase(id);
        check_material_coverage = true;
      }

      // also exclude mortar spaces from the material check
      auto & mortar_ifaces = _mesh.getMortarInterfaces();
      for (const auto & mortar_iface : mortar_ifaces)
        local_mesh_subs.erase(mortar_iface->_id);

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

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

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

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

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

  // Check UserObjects and Postprocessors
  checkUserObjects();

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

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