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

#include <FEProblemBase.h>

Inheritance diagram for FEProblemBase:

Classes
class	CreateTaggedMatrixKey

class	CurrentResidualVectorTagsKey
	Class that is used as a parameter to set/clearCurrentResidualVectorTags that allows only blessed classes to call said methods. More...

Public Types
enum class	CoverageCheckMode { FALSE , TRUE , OFF , ON , SKIP_LIST , ONLY_LIST }

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

Public Member Functions
	FEProblemBase (const InputParameters &parameters)

virtual	~FEProblemBase ()

bool	initialized () const

virtual libMesh::EquationSystems &	es () override

virtual MooseMesh &	mesh () override

virtual const MooseMesh &	mesh () const override

const MooseMesh &	mesh (bool use_displaced) const override

MooseMesh &	mesh (bool use_displaced)

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.

Moose::CouplingType	coupling () const

void	setCouplingMatrix (std::unique_ptr< libMesh::CouplingMatrix > cm, const unsigned int nl_sys_num)
	Set custom coupling matrix.

void	setCouplingMatrix (libMesh::CouplingMatrix *cm, const unsigned int nl_sys_num)

const libMesh::CouplingMatrix *	couplingMatrix (const unsigned int nl_sys_num) const override
	The coupling matrix defining what blocks exist in the preconditioning matrix.

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

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

bool	hasUOAuxStateCheck () const
	Whether or not MOOSE will perform a user object/auxiliary kernel state check.

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

virtual bool	checkResidualForNans () const override
	Whether to check residual for NaN/Inf values.

void	setCheckResidualForNans (bool check_residual_for_nans)
	Setter for residual NaN/Inf checking.

void	trustUserCouplingMatrix ()
	Whether to trust the user coupling matrix even if we want to do things like be paranoid and create a full coupling matrix.

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

std::vector< std::pair< MooseVariableFieldBase , MooseVariableFieldBase > > &	nonlocalCouplingEntries (const THREAD_ID tid, const unsigned int nl_sys_num)

const std::vector< std::pair< MooseVariableFieldBase , MooseVariableScalar > > &	fieldScalarCouplingEntries (const THREAD_ID tid, const unsigned int nl_sys_num) const

virtual bool	hasVariable (const std::string &var_name) const override
	Whether or not this problem has the variable.

bool	hasSolverVariable (const std::string &var_name) const

virtual const MooseVariableFieldBase &	getVariable (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const override
	Returns the variable reference for requested variable which must be of the expected_var_type (Nonlinear vs.

MooseVariableFieldBase &	getActualFieldVariable (const THREAD_ID tid, const std::string &var_name) override
	Returns the variable reference for requested MooseVariableField which may be in any system.

virtual MooseVariable &	getStandardVariable (const THREAD_ID tid, const std::string &var_name) override
	Returns the variable reference for requested MooseVariable which may be in any system.

virtual VectorMooseVariable &	getVectorVariable (const THREAD_ID tid, const std::string &var_name) override
	Returns the variable reference for requested VectorMooseVariable which may be in any system.

virtual ArrayMooseVariable &	getArrayVariable (const THREAD_ID tid, const std::string &var_name) override
	Returns the variable reference for requested ArrayMooseVariable which may be in any system.

virtual bool	hasScalarVariable (const std::string &var_name) const override
	Returns a Boolean indicating whether any system contains a variable with the name provided.

virtual MooseVariableScalar &	getScalarVariable (const THREAD_ID tid, const std::string &var_name) override
	Returns the scalar variable reference from whichever system contains it.

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

const RestartableEquationSystems &	getRestartableEquationSystems () const
	Get the RestartableEquationSystems object.

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

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

virtual void	clearActiveFEVariableCoupleableMatrixTags (const THREAD_ID tid) override

virtual void	clearActiveFEVariableCoupleableVectorTags (const THREAD_ID tid) override

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

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

virtual void	clearActiveScalarVariableCoupleableMatrixTags (const THREAD_ID tid) override

virtual void	clearActiveScalarVariableCoupleableVectorTags (const THREAD_ID tid) override

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

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

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

void	bumpVolumeQRuleOrder (libMesh::Order order, SubdomainID block)
	Increases the element/volume quadrature order for the specified mesh block if and only if the current volume quadrature order is lower.

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

unsigned int	getMaxQps () const

libMesh::Order	getMaxScalarOrder () const

void	checkNonlocalCoupling ()

void	checkUserObjectJacobianRequirement (THREAD_ID tid)

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

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

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

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

Moose::Kokkos::Assembly &	kokkosAssembly ()

const Moose::Kokkos::Assembly &	kokkosAssembly () const

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

void	initialSetup () override

void	checkDuplicatePostprocessorVariableNames ()

void	timestepSetup () override

void	customSetup (const ExecFlagType &exec_type) override

void	residualSetup () override

void	jacobianSetup () override

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

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

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

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

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

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

virtual void	prepareAssembly (const THREAD_ID tid) override

virtual void	prepareAssemblyNeighbor (const THREAD_ID tid)
	Begin a fresh neighbor accumulation phase by sizing and zeroing the neighbor blocks.

virtual void	addGhostedElem (dof_id_type elem_id) override
	Will make sure that all dofs connected to elem_id are ghosted to this processor.

virtual void	addGhostedBoundary (BoundaryID boundary_id) override
	Will make sure that all necessary elements from boundary_id are ghosted to this processor.

virtual void	ghostGhostedBoundaries () override
	Causes the boundaries added using addGhostedBoundary to actually be ghosted.

virtual void	sizeZeroes (unsigned int size, const THREAD_ID tid)

virtual bool	reinitDirac (const Elem *elem, const THREAD_ID tid) override
	Returns true if the Problem has Dirac kernels it needs to compute on elem.

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

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

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

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

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

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

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

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

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

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

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

virtual void	reinitScalars (const THREAD_ID tid, bool reinit_for_derivative_reordering=false) override
	fills the VariableValue arrays for scalar variables from the solution vector

virtual void	reinitOffDiagScalars (const THREAD_ID tid) override

virtual void	getDiracElements (std::set< const Elem * > &elems) override
	Fills "elems" with the elements that should be looped over for Dirac Kernels.

virtual void	clearDiracInfo () override
	Gets called before Dirac Kernels are asked to add the points they are supposed to be evaluated in.

virtual void	subdomainSetup (SubdomainID subdomain, const THREAD_ID tid)

virtual void	neighborSubdomainSetup (SubdomainID subdomain, const THREAD_ID tid)

virtual void	newAssemblyArray (std::vector< std::shared_ptr< SolverSystem > > &solver_systems)

virtual void	initNullSpaceVectors (const InputParameters &parameters, std::vector< std::shared_ptr< NonlinearSystemBase > > &nl)

virtual void	init () override

virtual void	solve (const unsigned int nl_sys_num)

void	initKokkos ()
	Construct Kokkos assembly and systems and allocate Kokkos material property storages.

virtual void	solveLinearSystem (const unsigned int linear_sys_num, const Moose::PetscSupport::PetscOptions *po=nullptr)
	Build and solve a linear system.

virtual void	setException (const std::string &message)
	Set an exception, which is stored at this point by toggling a member variable in this class, and which must be followed up with by a call to checkExceptionAndStopSolve().

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

virtual void	checkExceptionAndStopSolve (bool print_message=true)
	Check to see if an exception has occurred on any processor and, if possible, force the solve to fail, which will result in the time step being cut.

virtual bool	solverSystemConverged (const unsigned int solver_sys_num) override

virtual unsigned int	nNonlinearIterations (const unsigned int nl_sys_num) const override

virtual unsigned int	nLinearIterations (const unsigned int nl_sys_num) const override

virtual Real	finalNonlinearResidual (const unsigned int nl_sys_num) const override

virtual bool	computingPreSMOResidual (const unsigned int nl_sys_num) const override
	Returns true if the problem is in the process of computing it's initial residual.

virtual std::string	solverTypeString (unsigned int solver_sys_num=0)
	Return solver type as a human readable string.

virtual bool	startedInitialSetup ()
	Returns true if we are in or beyond the initialSetup stage.

virtual void	onTimestepBegin () override

virtual void	onTimestepEnd () override

virtual Real &	time () const

virtual Real &	timeOld () const

virtual Real &	timeOlder () const
	The time two steps back.

virtual int &	timeStep () const

virtual Real &	dt () const

virtual Real &	dtOld () const

Real	getTimeFromStateArg (const Moose::StateArg &state) const
	Returns the time associated with the requested `state`.

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

void	skipNextForwardSolutionCopyToOld ()
	Prevents the copy of the solution vector to the old solution vector in each system.

virtual void	advanceState ()
	Advance all of the state holding vectors / datastructures so that we can move to the next timestep.

virtual void	restoreSolutions ()

void	backupGeometricSearchState ()
	Snapshot geometric search state (both on the regular and, if present, the displaced mesh) so it can be restored with restoreGeometricSearchState() if this step is later rejected.

void	restoreGeometricSearchState ()
	Restore geometric search state captured by the most recent backupGeometricSearchState().

virtual void	saveOldSolutions ()
	Allocate vectors and save old solutions into them.

virtual void	restoreOldSolutions ()
	Restore old solutions from the backup vectors and deallocate them.

void	needSolutionState (unsigned int oldest_needed, Moose::SolutionIterationType iteration_type)
	Declare that we need up to old (1) or older (2) solution states for a given type of iteration.

bool	hasSolutionState (unsigned int state, Moose::SolutionIterationType iteration_type) const
	Whether we need up to old (1) or older (2) solution states for a given type of iteration.

virtual void	outputStep (ExecFlagType type)
	Output the current step.

virtual void	postExecute ()
	Method called at the end of the simulation.

void	forceOutput ()
	Indicates that the next call to outputStep should be forced.

virtual void	initPetscOutputAndSomeSolverSettings ()
	Reinitialize PETSc output for proper linear/nonlinear iteration display.

Moose::PetscSupport::PetscOptions &	getPetscOptions ()
	Retrieve a writable reference the PETSc options (used by PetscSupport)

void	logAdd (const std::string &system, const std::string &name, const std::string &type, const InputParameters &params) const
	Output information about the object just added to the problem.

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

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

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

virtual void	addKokkosFunction (const std::string &type, const std::string &name, InputParameters &parameters)
	Add a Kokkos function to the problem.

virtual bool	hasKokkosFunction (const std::string &name) const
	Get whether a Kokkos function exists.

virtual Moose::Kokkos::Function	getKokkosFunction (const std::string &name)
	Get a Kokkos function in an abstract type.

template<typename T >
T &	getKokkosFunction (const std::string &name)
	Get a Kokkos function in a concrete type.

virtual void	addMeshDivision (const std::string &type, const std::string &name, InputParameters &params)
	Add a MeshDivision.

MeshDivision &	getMeshDivision (const std::string &name, const THREAD_ID tid=0) const
	Get a MeshDivision.

virtual void	addConvergence (const std::string &type, const std::string &name, InputParameters &parameters)
	Adds a Convergence object.

virtual Convergence &	getConvergence (const std::string &name, const THREAD_ID tid=0) const
	Gets a Convergence object.

virtual const std::vector< std::shared_ptr< Convergence > > &	getConvergenceObjects (const THREAD_ID tid=0) const
	Gets the Convergence objects.

virtual bool	hasConvergence (const std::string &name, const THREAD_ID tid=0) const
	Returns true if the problem has a Convergence object of the given name.

bool	needToAddDefaultNonlinearConvergence () const
	Returns true if the problem needs to add the default nonlinear convergence.

bool	needToAddDefaultMultiAppFixedPointConvergence () const
	Returns true if the problem needs to add the default fixed point convergence.

bool	needToAddDefaultSteadyStateConvergence () const
	Returns true if the problem needs to add the default steady-state detection convergence.

void	setNeedToAddDefaultNonlinearConvergence ()
	Sets _need_to_add_default_nonlinear_convergence to true.

void	setNeedToAddDefaultMultiAppFixedPointConvergence ()
	Sets _need_to_add_default_multiapp_fixed_point_convergence to true.

void	setNeedToAddDefaultSteadyStateConvergence ()
	Sets _need_to_add_default_steady_state_convergence to true.

bool	hasSetMultiAppFixedPointConvergenceName () const
	Returns true if the problem has set the fixed point convergence name.

bool	hasSetSteadyStateConvergenceName () const
	Returns true if the problem has set the steady-state detection convergence name.

virtual void	addDefaultNonlinearConvergence (const InputParameters &params)
	Adds the default nonlinear Convergence associated with the problem.

virtual bool	onlyAllowDefaultNonlinearConvergence () const
	Returns true if an error will result if the user supplies 'nonlinear_convergence'.

void	addDefaultMultiAppFixedPointConvergence (const InputParameters &params)
	Adds the default fixed point Convergence associated with the problem.

void	addDefaultSteadyStateConvergence (const InputParameters &params)
	Adds the default steady-state detection Convergence.

virtual void	addLineSearch (const InputParameters &)
	add a MOOSE line search

virtual void	lineSearch ()
	execute MOOSE line search

LineSearch *	getLineSearch () override
	getter for the MOOSE line search

virtual void	addDistribution (const std::string &type, const std::string &name, InputParameters &parameters)
	The following functions will enable MOOSE to have the capability to import distributions.

virtual bool	hasDistribution (const std::string &name) const

virtual Distribution &	getDistribution (const std::string &name)

virtual void	addSampler (const std::string &type, const std::string &name, InputParameters &parameters)
	The following functions will enable MOOSE to have the capability to import Samplers.

virtual Sampler &	getSampler (const std::string &name, const THREAD_ID tid=0)

NonlinearSystemBase &	getNonlinearSystemBase (const unsigned int sys_num)

const NonlinearSystemBase &	getNonlinearSystemBase (const unsigned int sys_num) const

void	setCurrentNonlinearSystem (const unsigned int nl_sys_num)

NonlinearSystemBase &	currentNonlinearSystem ()

const NonlinearSystemBase &	currentNonlinearSystem () const

virtual const SystemBase &	systemBaseNonlinear (const unsigned int sys_num) const override
	Return the nonlinear system object as a base class reference given the system number.

virtual SystemBase &	systemBaseNonlinear (const unsigned int sys_num) override

virtual const SystemBase &	systemBaseSolver (const unsigned int sys_num) const override
	Return the solver system object as a base class reference given the system number.

virtual SystemBase &	systemBaseSolver (const unsigned int sys_num) override

virtual const SystemBase &	systemBaseAuxiliary () const override
	Return the auxiliary system object as a base class reference.

virtual SystemBase &	systemBaseAuxiliary () override

virtual NonlinearSystem &	getNonlinearSystem (const unsigned int sys_num)

virtual const SystemBase &	getSystemBase (const unsigned int sys_num) const
	Get constant reference to a system in this problem.

virtual SystemBase &	getSystemBase (const unsigned int sys_num)
	Get non-constant reference to a system in this problem.

SystemBase &	getSystemBase (const std::string &sys_name)
	Get non-constant reference to a system in this problem.

LinearSystem &	getLinearSystem (unsigned int sys_num)
	Get non-constant reference to a linear system.

const LinearSystem &	getLinearSystem (unsigned int sys_num) const
	Get a constant reference to a linear system.

SolverSystem &	getSolverSystem (unsigned int sys_num)
	Get non-constant reference to a solver system.

const SolverSystem &	getSolverSystem (unsigned int sys_num) const
	Get a constant reference to a solver system.

void	setCurrentLinearSystem (unsigned int sys_num)
	Set the current linear system pointer.

LinearSystem &	currentLinearSystem ()
	Get a non-constant reference to the current linear system.

const LinearSystem &	currentLinearSystem () const
	Get a constant reference to the current linear system.

virtual const SystemBase &	systemBaseLinear (unsigned int sys_num) const override
	Get a constant base class reference to a linear system.

virtual SystemBase &	systemBaseLinear (unsigned int sys_num) override
	Get a non-constant base class reference to a linear system.

virtual void	addVariable (const std::string &var_type, const std::string &var_name, InputParameters &params)
	Canonical method for adding a non-linear variable.

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

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

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

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

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

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

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

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

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

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

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

virtual void	setInputParametersFEProblem (InputParameters &parameters)

virtual void	addAuxVariable (const std::string &var_type, const std::string &var_name, InputParameters &params)
	Canonical method for adding an auxiliary variable.

virtual void	addElementalFieldVariable (const std::string &var_type, const std::string &var_name, InputParameters &params)
	Add an elemental field variable for use in the adaptivity system.

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

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

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

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

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

AuxiliarySystem &	getAuxiliarySystem ()

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

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

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

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

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

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

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

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

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

virtual void	addFVInitialCondition (const std::string &ic_name, const std::string &name, InputParameters &parameters)
	Add an initial condition for a finite volume variables.

void	projectSolution ()

unsigned short	getCurrentICState ()
	Retrieves the current initial condition state.

void	projectInitialConditionOnCustomRange (libMesh::ConstElemRange &elem_range, ConstBndNodeRange &bnd_node_range, const std::optional< std::set< VariableName > > &target_vars=std::nullopt)
	Project initial conditions for custom `elem_range` and `bnd_node_range` This is needed when elements/boundary nodes are added to a specific subdomain at an intermediate step.

void	projectFunctionOnCustomRange (ConstElemRange &elem_range, Number(func)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), Gradient(func_grad)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &), const libMesh::Parameters &params, const std::vector< VariableName > &target_vars)
	Project a function onto a range of elements for a given variable.

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

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

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

virtual void	addFunctorMaterial (const std::string &functor_material_name, const std::string &name, InputParameters &parameters)

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

void	prepareMaterials (const std::unordered_set< unsigned int > &consumer_needed_mat_props, const SubdomainID blk_id, const THREAD_ID tid)
	Add the MooseVariables and the material properties that the current materials depend on to the dependency list.

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

void	reinitMaterialsFace (SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase * > *reinit_mats=nullptr)
	reinit materials on element faces

void	reinitMaterialsFaceOnBoundary (const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase * > *const reinit_mats=nullptr)
	reinit materials on element faces on a boundary (internal or external) This specific routine helps us not reinit when don't need to

void	reinitMaterialsNeighborOnBoundary (const BoundaryID boundary_id, const SubdomainID blk_id, const THREAD_ID tid, const bool swap_stateful=true, const std::deque< MaterialBase * > *const reinit_mats=nullptr)
	reinit materials on neighbor element (usually faces) on a boundary (internal or external) This specific routine helps us not reinit when don't need to

void	reinitMaterialsNeighbor (SubdomainID blk_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase * > *reinit_mats=nullptr)
	reinit materials on the neighboring element face

void	reinitMaterialsBoundary (BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true, const std::deque< MaterialBase * > *reinit_mats=nullptr)
	reinit materials on a boundary

void	reinitMaterialsInterface (BoundaryID boundary_id, const THREAD_ID tid, bool swap_stateful=true)

void	prepareKokkosMaterials (const std::unordered_set< unsigned int > &consumer_needed_mat_props)

void	reinitKokkosMaterials ()

virtual void	swapBackMaterials (const THREAD_ID tid)

virtual void	swapBackMaterialsFace (const THREAD_ID tid)

virtual void	swapBackMaterialsNeighbor (const THREAD_ID tid)

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

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

void	clearActiveMaterialProperties (const THREAD_ID tid)
	Clear the active material properties.

template<typename T >
std::vector< std::shared_ptr< T > >	addObject (const std::string &type, const std::string &name, InputParameters &parameters, const bool threaded=true, const std::string &var_param_name="variable")
	Method for creating and adding an object to the warehouse.

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

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

virtual void	addReporter (const std::string &type, const std::string &name, InputParameters &parameters)
	Add a Reporter object to the simulation.

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

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

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

const ReporterData &	getReporterData () const
	Provides const access the ReporterData object.

ReporterData &	getReporterData (ReporterData::WriteKey)
	Provides non-const access the ReporterData object that is used to store reporter values.

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

template<class T >
T &	getUserObject (const std::string &name, unsigned int tid=0) const
	Get the user object by its name.

const UserObject &	getUserObjectBase (const std::string &name, const THREAD_ID tid=0) const
	Get the user object by its name.

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

virtual void	addKokkosUserObject (const std::string &user_object_name, const std::string &name, InputParameters &parameters)

template<class T >
const T &	getKokkosUserObject (const std::string &name) const
	Get the Kokkos user object by its name.

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

void	checkUserObjectNameCollision (const std::string &name, const std::string &type) const
	Check for name collision between different user objects.

const Positions &	getPositionsObject (const std::string &name) const
	Get the Positions object by its name.

virtual void	addFVInterpolationMethod (const std::string &method_type, const std::string &name, InputParameters &parameters)
	Add an FV interpolation method.

virtual void	addFVGradientMethod (const std::string &method_type, const std::string &name, InputParameters &parameters)
	Add an FV gradient method.

FVGradientMethod &	getFVGradientMethod (const GradientMethodName &name, const THREAD_ID tid=0)
	Retrieve a writable FV gradient method owned by this problem.

const FVGradientMethod &	getFVGradientMethod (const GradientMethodName &name, const THREAD_ID tid=0) const
	Retrieve a read-only FV gradient method owned by this problem.

bool	hasFVGradientMethod (const GradientMethodName &name) const
	Check if an FV gradient method with a given name exists.

const FVInterpolationMethod &	getFVInterpolationMethod (const InterpolationMethodName &name, const THREAD_ID tid=0) const
	Retrieve an FV interpolation method.

const FVFaceInterpolationMethod &	getFVFaceInterpolationMethod (const InterpolationMethodName &name, const THREAD_ID tid=0) const
	Retrieve a scalar face interpolation method.

const FVAdvectedInterpolationMethod &	getFVAdvectedInterpolationMethod (const InterpolationMethodName &name, const THREAD_ID tid=0) const
	Retrieve an advected interpolation method.

bool	hasFVInterpolationMethod (const InterpolationMethodName &name) const
	Check if an FV interpolation method with a given name exists.

bool	hasPostprocessorValueByName (const PostprocessorName &name) const
	Whether or not a Postprocessor value exists by a given name.

const Postprocessor &	getPostprocessorObjectByName (const PostprocessorName &object_name, const THREAD_ID tid=0) const
	Return the Postprocessor object registered under the supplied object name.

const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name, std::size_t t_index=0) const
	Get a read-only reference to the value associated with a Postprocessor that exists.

void	setPostprocessorValueByName (const PostprocessorName &name, const PostprocessorValue &value, std::size_t t_index=0)
	Set the value of a PostprocessorValue.

bool	hasPostprocessor (const std::string &name) const
	Deprecated.

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const std::string &object_name, const std::string &vector_name, std::size_t t_index=0) const
	Get a read-only reference to the vector value associated with the VectorPostprocessor.

void	setVectorPostprocessorValueByName (const std::string &object_name, const std::string &vector_name, const VectorPostprocessorValue &value, std::size_t t_index=0)
	Set the value of a VectorPostprocessor vector.

const VectorPostprocessor &	getVectorPostprocessorObjectByName (const std::string &object_name, const THREAD_ID tid=0) const
	Return the VPP object given the name.

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

void	setupDampers ()

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

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

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

virtual void	addMultiApp (const std::string &multi_app_name, const std::string &name, InputParameters &parameters)
	Add a MultiApp to the problem.

std::shared_ptr< MultiApp >	getMultiApp (const std::string &multi_app_name) const
	Get a MultiApp object by name.

std::vector< std::shared_ptr< Transfer > >	getTransfers (ExecFlagType type, Transfer::DIRECTION direction) const
	Get Transfers by ExecFlagType and direction.

std::vector< std::shared_ptr< Transfer > >	getTransfers (Transfer::DIRECTION direction) const

const ExecuteMooseObjectWarehouse< Transfer > &	getMultiAppTransferWarehouse (Transfer::DIRECTION direction) const
	Return the complete warehouse for MultiAppTransfer object for the given direction.

void	execMultiAppTransfers (ExecFlagType type, Transfer::DIRECTION direction, const MultiAppName &source_app="")
	Execute MultiAppTransfers associated with execution flag and direction.

bool	execMultiApps (ExecFlagType type, bool auto_advance=true)
	Execute the MultiApps associated with the ExecFlagType.

unsigned int	numConcurrentMultiApps () const

void	partitionConcurrentMultiApps ()
	Assign each multiapp that shares an 'execution_order_group' with others a disjoint subset of the ranks so that they can be solved concurrently (at most one child app per rank at a time).

void	finalizeMultiApps ()

void	incrementMultiAppTStep (ExecFlagType type)
	Advance the MultiApps t_step (incrementStepOrReject) associated with the ExecFlagType.

void	advanceMultiApps (ExecFlagType type)
	Deprecated method; use finishMultiAppStep and/or incrementMultiAppTStep depending on your purpose.

void	finishMultiAppStep (ExecFlagType type, bool recurse_through_multiapp_levels=false)
	Finish the MultiApp time step (endStep, postStep) associated with the ExecFlagType.

void	backupMultiApps (ExecFlagType type)
	Backup the MultiApps associated with the ExecFlagType.

void	restoreMultiApps (ExecFlagType type, bool force=false)
	Restore the MultiApps associated with the ExecFlagType.

Real	computeMultiAppsDT (ExecFlagType type)
	Find the smallest timestep over all MultiApps.

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

Real	computeResidualL2Norm (NonlinearSystemBase &sys)
	Computes the residual of a nonlinear system using whatever is sitting in the current solution vector then returns the L2 norm.

Real	computeResidualL2Norm (LinearSystem &sys)
	Computes the residual of a linear system using whatever is sitting in the current solution vector then returns the L2 norm.

virtual Real	computeResidualL2Norm ()
	Computes the residual using whatever is sitting in the current solution vector then returns the L2 norm.

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

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

virtual void	computeResidual (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, const unsigned int nl_sys_num)
	Form a residual with default tags (nontime, time, residual).

void	computeResidualAndJacobian (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, libMesh::SparseMatrix< libMesh::Number > &jacobian)
	Form a residual and Jacobian with default tags.

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

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

virtual void	computeResidualInternal (const NumericVector< libMesh::Number > &soln, NumericVector< libMesh::Number > &residual, const std::set< TagID > &tags)
	Form a residual vector for a set of tags.

virtual void	computeResidualTags (const std::set< TagID > &tags)
	Form multiple residual vectors and each is associated with one tag.

virtual void	computeJacobianSys (libMesh::NonlinearImplicitSystem &sys, const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian)
	Form a Jacobian matrix.

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

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

virtual void	computeJacobianInternal (const NumericVector< libMesh::Number > &soln, libMesh::SparseMatrix< libMesh::Number > &jacobian, const std::set< TagID > &tags)
	Form a Jacobian matrix for multiple tags.

virtual void	computeJacobianTags (const std::set< TagID > &tags)
	Form multiple matrices, and each is associated with a tag.

virtual void	computeJacobianBlocks (std::vector< JacobianBlock * > &blocks, const unsigned int nl_sys_num)
	Computes several Jacobian blocks simultaneously, summing their contributions into smaller preconditioning matrices.

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

virtual void	computeLinearSystemSys (libMesh::LinearImplicitSystem &sys, libMesh::SparseMatrix< libMesh::Number > &system_matrix, NumericVector< libMesh::Number > &rhs, const bool compute_gradients=true)
	Assemble both the right hand side and the system matrix of a given linear system.

void	computeLinearSystemTags (const NumericVector< libMesh::Number > &soln, const std::set< TagID > &vector_tags, const std::set< TagID > &matrix_tags, const bool compute_gradients=true)
	Assemble the current linear system given a set of vector and matrix tags.

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

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

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

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

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

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

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

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

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

virtual void	computeIndicatorsAndMarkers ()

virtual void	computeIndicators ()

virtual void	computeMarkers ()

virtual void	addResidual (const THREAD_ID tid) override

virtual void	addResidualNeighbor (const THREAD_ID tid) override

virtual void	addResidualLower (const THREAD_ID tid) override

virtual void	addResidualScalar (const THREAD_ID tid=0)

virtual void	cacheResidual (const THREAD_ID tid) override

virtual void	cacheResidualNeighbor (const THREAD_ID tid) override

virtual void	addCachedResidual (const THREAD_ID tid) override

virtual void	addCachedResidualDirectly (NumericVector< libMesh::Number > &residual, const THREAD_ID tid)
	Allows for all the residual contributions that are currently cached to be added directly into the vector passed in.

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

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

virtual void	addJacobian (const THREAD_ID tid) override

virtual void	addJacobianNeighbor (const THREAD_ID tid) override

virtual void	addJacobianNeighborLowerD (const THREAD_ID tid) override

virtual void	addJacobianLowerD (const THREAD_ID tid) override

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

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

virtual void	addJacobianScalar (const THREAD_ID tid=0)

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

virtual void	cacheJacobian (const THREAD_ID tid) override

virtual void	cacheJacobianNeighbor (const THREAD_ID tid) override

virtual void	addCachedJacobian (const THREAD_ID tid) override

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

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

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

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

virtual std::shared_ptr< const DisplacedProblem >	getDisplacedProblem () const

virtual std::shared_ptr< DisplacedProblem >	getDisplacedProblem ()

virtual void	updateGeomSearch (GeometricSearchData::GeometricSearchType type=GeometricSearchData::ALL) override
	Update this object's geometric search data as well as the displaced problem's if it exists.

virtual void	updateMortarMesh ()

void	createMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced, bool periodic, const bool debug, const bool correct_edge_dropping, const Real minimum_projection_angle, const Mortar3DSubpatchPlane mortar_3d_subpatch_plane, const MooseEnum &triangulation, const bool triangulate_triangles, const Mortar3DQuadraturePointMapping mortar_3d_qp_mapping=Mortar3DQuadraturePointMapping::NORMAL_PROJECTION)

const std::unordered_map< std::pair< BoundaryID, BoundaryID >, MortarInterfaceConfig > &	getMortarInterfaces (bool on_displaced) const

virtual void	possiblyRebuildGeomSearchPatches ()

virtual GeometricSearchData &	geomSearchData () override

void	setRestartFile (const std::string &file_name)
	Communicate to the Resurector the name of the restart filer.

const MaterialPropertyRegistry &	getMaterialPropertyRegistry () const

const InitialConditionWarehouse &	getInitialConditionWarehouse () const
	Return InitialCondition storage.

const FVInitialConditionWarehouse &	getFVInitialConditionWarehouse () const
	Return FVInitialCondition storage.

SolverParams &	solverParams (unsigned int solver_sys_num=0)
	Get the solver parameters.

const SolverParams &	solverParams (unsigned int solver_sys_num=0) const
	const version

Adaptivity &	adaptivity ()

virtual void	initialAdaptMesh ()

virtual bool	adaptMesh ()

unsigned int	getNumCyclesCompleted ()

bool	hasInitialAdaptivity () const
	Return a Boolean indicating whether initial AMR is turned on.

bool	hasInitialAdaptivity () const
	Return a Boolean indicating whether initial AMR is turned on.

void	initXFEM (std::shared_ptr< XFEMInterface > xfem)
	Create XFEM controller object.

std::shared_ptr< XFEMInterface >	getXFEM ()
	Get a pointer to the XFEM controller object.

bool	haveXFEM ()
	Find out whether the current analysis is using XFEM.

virtual bool	updateMeshXFEM ()
	Update the mesh due to changing XFEM cuts.

virtual bool	allowMeshContractionAfterMeshChanged () const
	Whether meshChanged() should allow the mesh to be contracted (deletes children of coarsened elements and renumbers nodes and elements).

virtual void	meshChanged (bool intermediate_change, bool contract_mesh, bool clean_refinement_flags)
	Update data after a mesh change.

void	notifyWhenMeshChanges (MeshChangedInterface *mci)
	Register an object that derives from MeshChangedInterface to be notified when the mesh changes.

void	notifyWhenMeshDisplaces (MeshDisplacedInterface *mdi)
	Register an object that derives from MeshDisplacedInterface to be notified when the displaced mesh gets updated.

void	initElementStatefulProps (const libMesh::ConstElemRange &elem_range, const bool threaded)
	Initialize stateful properties for elements in a specific `elem_range` This is needed when elements/boundary nodes are added to a specific subdomain at an intermediate step.

void	initKokkosStatefulProps ()

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

void	registerRandomInterface (RandomInterface &random_interface, const std::string &name)

void	setConstJacobian (bool state)
	Set flag that Jacobian is constant (for optimization purposes)

void	setKernelCoverageCheck (CoverageCheckMode mode)
	Set flag to indicate whether kernel coverage checks should be performed.

void	setKernelCoverageCheck (bool flag)
	Set flag to indicate whether kernel coverage checks should be performed.

void	setMaterialCoverageCheck (CoverageCheckMode mode)
	Set flag to indicate whether material coverage checks should be performed.

void	setMaterialCoverageCheck (bool flag)
	Set flag to indicate whether material coverage checks should be performed.

void	setParallelBarrierMessaging (bool flag)
	Toggle parallel barrier messaging (defaults to on).

void	setVerboseProblem (bool verbose)
	Make the problem be verbose.

bool	verboseMultiApps () const
	Whether or not to use verbose printing for MultiApps.

void	parentOutputPositionChanged ()
	Calls parentOutputPositionChanged() on all sub apps.

unsigned int	subspaceDim (const std::string &prefix) const
	Dimension of the subspace spanned by vectors with a given prefix.

const MooseObjectWarehouse< Function > &	getFunctionWarehouse ()

const MaterialWarehouse &	getMaterialWarehouse () const

const MaterialWarehouse &	getRegularMaterialsWarehouse () const

const MaterialWarehouse &	getDiscreteMaterialWarehouse () const

const MaterialWarehouse &	getInterfaceMaterialsWarehouse () const

const MaterialWarehouse &	getKokkosMaterialsWarehouse () const

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

MaterialData &	getMaterialData (Moose::MaterialDataType type, const THREAD_ID tid=0, const MooseObject *object=nullptr) const

MaterialData &	getKokkosMaterialData (Moose::MaterialDataType type, const MooseObject *object=nullptr) const

const std::set< const MooseObject * > &	getMaterialPropertyStorageConsumers (Moose::MaterialDataType type) const

const std::set< const MooseObject * > &	getKokkosMaterialPropertyStorageConsumers (Moose::MaterialDataType type) const

bool	restoreOriginalNonzeroPattern () const

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

void	setErrorOnJacobianNonzeroReallocation (bool state)

bool	preserveMatrixSparsityPattern () const
	Will return True if the executioner in use requires preserving the sparsity pattern of the matrices being formed during the solve.

void	setPreserveMatrixSparsityPattern (bool preserve)
	Set whether the sparsity pattern of the matrices being formed during the solve (usually the Jacobian) should be preserved.

bool	ignoreZerosInJacobian () const
	Will return true if zeros in the Jacobian are to be dropped from the sparsity pattern.

void	setIgnoreZerosInJacobian (bool state)
	Set whether the zeros in the Jacobian should be dropped from the sparsity pattern.

bool	acceptInvalidSolution () const
	Whether or not to accept the solution based on its invalidity.

bool	allowInvalidSolution () const
	Whether to accept / allow an invalid solution.

bool	showInvalidSolutionConsole () const
	Whether or not to print out the invalid solutions summary table in console.

bool	immediatelyPrintInvalidSolution () const
	Whether or not the solution invalid warnings are printed out immediately.

bool	hasTimeIntegrator () const
	Returns whether or not this Problem has a TimeIntegrator.

virtual void	execute (const ExecFlagType &exec_type)
	Convenience function for performing execution of MOOSE systems.

virtual void	executeAllObjects (const ExecFlagType &exec_type)

virtual Executor &	getExecutor (const std::string &name)

virtual void	computeUserObjects (const ExecFlagType &type, const Moose::AuxGroup &group)
	Call compute methods on UserObjects.

virtual void	computeUserObjectByName (const ExecFlagType &type, const Moose::AuxGroup &group, const std::string &name)
	Compute an user object with the given name.

void	needsPreviousNewtonIteration (bool state)
	Set a flag that indicated that user required values for the previous Newton iterate.

bool	needsPreviousNewtonIteration () const
	Check to see whether we need to compute the variable values of the previous Newton iterate.

void	needsPreviousMultiAppFixedPointIterationSolution (bool needed, const unsigned int solver_sys_num)
	Set a flag that indicated that user required values for the previous multiapp fixed point iterate for the solver systems (not auxiliary)

bool	needsPreviousMultiAppFixedPointIterationSolution (const unsigned int solver_sys_num) const
	Check to see whether we need to compute the variable values of the previous multiapp fixed point iteration for the solver systems (not auxiliary)

void	needsPreviousMultiAppFixedPointIterationAuxiliary (bool state)
	Set a flag that indicated that user required values for the previous multiapp fixed point iterate for the auxiliary system.

bool	needsPreviousMultiAppFixedPointIterationAuxiliary () const
	Check to see whether we need to compute the variable values of the previous multiapp fixed point iteration for the auxiliary system.

void	needsPreviousMultiSystemFixedPointIterationSolution (bool needed, const unsigned int solver_sys_num)
	Set a flag that indicates that user requires values for the previous multi-system fixed point iterate for the solver systems (not auxiliary)

bool	needsPreviousMultiSystemFixedPointIterationSolution (const unsigned int solver_sys_num) const
	Check to see whether we need to compute the variable values of the previous multi-system fixed point iteration for the solver systems (not auxiliary)

void	needsPreviousMultiSystemFixedPointIterationAuxiliary (bool state)
	Set a flag that indicates that user requires values for the previous multi-system fixed point iterate for the auxiliary system.

bool	needsPreviousMultiSystemFixedPointIterationAuxiliary () const
	Check to see whether we need to compute the variable values of the previous multi-system fixed point iteration for the auxiliary system.

ExecuteMooseObjectWarehouse< Control > &	getControlWarehouse ()
	Reference to the control logic warehouse.

void	executeControls (const ExecFlagType &exec_type)
	Performs setup and execute calls for Control objects.

void	executeSamplers (const ExecFlagType &exec_type)
	Performs setup and execute calls for Sampler objects.

virtual void	updateActiveObjects ()
	Update the active objects in the warehouses.

void	reportMooseObjectDependency (MooseObject a, MooseObject b)
	Register a MOOSE object dependency so we can either order operations properly or report when we cannot.

ExecuteMooseObjectWarehouse< MultiApp > &	getMultiAppWarehouse ()

bool	hasJacobian () const
	Returns _has_jacobian.

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)

void	addOutput (const std::string &, const std::string &, InputParameters &)
	Adds an Output object.

TheWarehouse &	theWarehouse () const

void	setSNESMFReuseBase (bool reuse, bool set_by_user)
	If or not to reuse the base vector for matrix-free calculation.

bool	useSNESMFReuseBase ()
	Return a flag that indicates if we are reusing the vector base.

void	skipExceptionCheck (bool skip_exception_check)
	Set a flag that indicates if we want to skip exception and stop solve.

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

bool &	petscOptionsInserted ()
	If PETSc options are already inserted.

PetscOptions &	petscOptionsDatabase ()

virtual void	setUDotRequested (const bool u_dot_requested)
	Set boolean flag to true to store solution time derivative.

virtual void	setUDotDotRequested (const bool u_dotdot_requested)
	Set boolean flag to true to store solution second time derivative.

virtual void	setUDotOldRequested (const bool u_dot_old_requested)
	Set boolean flag to true to store old solution time derivative.

virtual void	setUDotDotOldRequested (const bool u_dotdot_old_requested)
	Set boolean flag to true to store old solution second time derivative.

virtual bool	uDotRequested ()
	Get boolean flag to check whether solution time derivative needs to be stored.

virtual bool	uDotDotRequested ()
	Get boolean flag to check whether solution second time derivative needs to be stored.

virtual bool	uDotOldRequested ()
	Get boolean flag to check whether old solution time derivative needs to be stored.

virtual bool	uDotDotOldRequested ()
	Get boolean flag to check whether old solution second time derivative needs to be stored.

void	haveADObjects (bool have_ad_objects) override
	Method for setting whether we have any ad objects.

bool	shouldSolve () const

const MortarInterfaceWarehouse &	mortarData () const
	Returns the mortar data object.

MortarInterfaceWarehouse &	mortarData ()

virtual bool	hasNeighborCoupling () const
	Whether the simulation has neighbor coupling.

virtual bool	hasMortarCoupling () const
	Whether the simulation has mortar coupling.

void	computingNonlinearResid (bool computing_nonlinear_residual) final
	Set whether or not the problem is in the process of computing the nonlinear residual.

void	setCurrentlyComputingResidual (bool currently_computing_residual) final
	Set whether or not the problem is in the process of computing the residual.

void	numGridSteps (unsigned int num_grid_steps)
	Set the number of steps in a grid sequences.

void	uniformRefine ()
	uniformly refine the problem mesh(es).

void	automaticScaling (bool automatic_scaling) override
	Automatic scaling setter.

virtual void	reinitElemFaceRef (const Elem elem, unsigned int side, Real tolerance, const std::vector< Point > const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0) override
	reinitialize FE objects on a given element on a given side at a given set of reference points and then compute variable data.

virtual void	reinitNeighborFaceRef (const Elem neighbor_elem, unsigned int neighbor_side, Real tolerance, const std::vector< Point > const pts, const std::vector< Real > *const weights=nullptr, const THREAD_ID tid=0) override
	reinitialize FE objects on a given neighbor element on a given side at a given set of reference points and then compute variable data.

bool	fvBCsIntegrityCheck () const

bool	sideUOInterfaceMatPropIntegrityCheck () const

void	fvBCsIntegrityCheck (bool fv_bcs_integrity_check)

void	getFVMatsAndDependencies (SubdomainID block_id, std::vector< std::shared_ptr< MaterialBase > > &face_materials, std::vector< std::shared_ptr< MaterialBase > > &neighbor_materials, std::set< MooseVariableFieldBase * > &variables, const THREAD_ID tid)
	Get the materials and variables potentially needed for FV.

void	resizeMaterialData (Moose::MaterialDataType data_type, unsigned int nqp, const THREAD_ID tid)
	Resize material data.

bool	haveDisplaced () const override final
	Whether we have a displaced problem in our simulation.

bool	hasLinearConvergenceObjects () const
	Whether we have linear convergence objects.

void	setNonlinearConvergenceNames (const std::vector< ConvergenceName > &convergence_names)
	Sets the nonlinear convergence object name(s) if there is one.

void	setLinearConvergenceNames (const std::vector< ConvergenceName > &convergence_names)
	Sets the linear convergence object name(s) if there is one.

void	setMultiAppFixedPointConvergenceName (const ConvergenceName &convergence_name)
	Sets the MultiApp fixed point convergence object name if there is one.

void	setSteadyStateConvergenceName (const ConvergenceName &convergence_name)
	Sets the steady-state detection convergence object name if there is one.

const std::vector< ConvergenceName > &	getNonlinearConvergenceNames () const
	Gets the nonlinear system convergence object name(s).

const std::vector< ConvergenceName > &	getLinearConvergenceNames () const
	Gets the linear convergence object name(s).

const ConvergenceName &	getMultiAppFixedPointConvergenceName () const
	Gets the MultiApp fixed point convergence object name.

const ConvergenceName &	getSteadyStateConvergenceName () const
	Gets the steady-state detection convergence object name.

void	computingScalingJacobian (bool computing_scaling_jacobian)
	Setter for whether we're computing the scaling jacobian.

bool	computingScalingJacobian () const override final
	Getter for whether we're computing the scaling jacobian.

void	computingScalingResidual (bool computing_scaling_residual)
	Setter for whether we're computing the scaling residual.

bool	computingScalingResidual () const override final

MooseAppCoordTransform &	coordTransform ()

virtual std::size_t	numNonlinearSystems () const override

virtual std::size_t	numLinearSystems () const override

virtual std::size_t	numSolverSystems () const override

bool	isSolverSystemNonlinear (const unsigned int sys_num)
	Check if the solver system is nonlinear.

virtual unsigned int	currentNlSysNum () const override

virtual unsigned int	currentLinearSysNum () const override

virtual unsigned int	nlSysNum (const NonlinearSystemName &nl_sys_name) const override

unsigned int	linearSysNum (const LinearSystemName &linear_sys_name) const override

unsigned int	solverSysNum (const SolverSystemName &solver_sys_name) const override

unsigned int	systemNumForVariable (const VariableName &variable_name) const

bool	getFailNextNonlinearConvergenceCheck () const
	Whether it will skip further residual evaluations and fail the next nonlinear convergence check(s)

bool	getFailNextSystemConvergenceCheck () const
	Whether it will fail the next system convergence check(s), triggering failed step behavior.

void	setFailNextNonlinearConvergenceCheck ()
	Skip further residual evaluations and fail the next nonlinear convergence check(s)

void	setFailNextSystemConvergenceCheck ()
	Tell the problem that the system(s) cannot be considered converged next time convergence is checked.

void	resetFailNextNonlinearConvergenceCheck ()
	Tell the problem that the nonlinear convergence check(s) may proceed as normal.

void	resetFailNextSystemConvergenceCheck ()
	Tell the problem that the system convergence check(s) may proceed as normal.

void	setExecutionPrinting (const ExecFlagEnum &print_exec)

bool	shouldPrintExecution (const THREAD_ID tid) const
	Check whether the problem should output execution orders at this time.

void	reinitMortarUserObjects (BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced)
	Call `reinit` on mortar user objects with matching primary boundary ID, secondary boundary ID, and displacement characteristics.

virtual const std::vector< VectorTag > &	currentResidualVectorTags () const override
	Return the residual vector tags we are currently computing.

void	setCurrentResidualVectorTags (const std::set< TagID > &vector_tags)
	Set the current residual vector tag data structure based on the passed in tag IDs.

void	clearCurrentResidualVectorTags ()
	Clear the current residual vector tag data structure.

void	clearCurrentJacobianMatrixTags ()
	Clear the current Jacobian matrix tag data structure ... if someone creates it.

virtual void	needFV () override
	marks this problem as including/needing finite volume functionality.

virtual bool	haveFV () const override
	returns true if this problem includes/needs finite volume functionality.

virtual bool	hasNonlocalCoupling () const override
	Whether the simulation has active nonlocal coupling which should be accounted for in the Jacobian.

bool	identifyVariableGroupsInNL () const
	Whether to identify variable groups in nonlinear systems.

virtual void	setCurrentLowerDElem (const Elem *const lower_d_elem, const THREAD_ID tid) override
	Set the current lower dimensional element.

virtual void	setCurrentBoundaryID (BoundaryID bid, const THREAD_ID tid) override
	sets the current boundary ID in assembly

const std::vector< NonlinearSystemName > &	getNonlinearSystemNames () const

const std::vector< LinearSystemName > &	getLinearSystemNames () const

const std::vector< SolverSystemName > &	getSolverSystemNames () const

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

virtual bool	checkNonlocalCouplingRequirement () const override

virtual Moose::FEBackend	feBackend () const

void	createTagMatrices (CreateTaggedMatrixKey)

bool	useHashTableMatrixAssembly () const

bool	hasKokkosObjects () const

bool	hasKokkosResidualObjects () const

void	addKokkosMeshInitializationHook (std::function< void()> function)
	Add a function hook that needs to be called after Kokkos mesh initialization.

virtual const MooseVariableFieldBase &	getVariable (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type=Moose::VarKindType::VAR_ANY, Moose::VarFieldType expected_var_field_type=Moose::VarFieldType::VAR_FIELD_ANY) const=0
	Returns the variable reference for requested variable which must be of the expected_var_type (Nonlinear vs.

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

virtual void	haveADObjects (bool have_ad_objects)
	Method for setting whether we have any ad objects.

bool	haveADObjects () const
	Method for reading wehther we have any ad objects.

bool	computingNonlinearResid () const
	Returns true if the problem is in the process of computing the nonlinear residual.

virtual void	computingNonlinearResid (const bool computing_nonlinear_residual)
	Set whether or not the problem is in the process of computing the nonlinear residual.

const bool &	currentlyComputingResidual () const
	Returns true if the problem is in the process of computing the residual.

virtual void	automaticScaling (bool automatic_scaling)
	Automatic scaling setter.

bool	automaticScaling () const
	Automatic scaling getter.

THREAD_ID	numThreads () const

virtual bool	nlConverged (const unsigned int nl_sys_num)

virtual bool	converged (const unsigned int sys_num)
	Eventually we want to convert this virtual over to taking a solver system number argument.

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

virtual TagID	addVectorTag (const TagName &tag_name, const Moose::VectorTagType type=Moose::VECTOR_TAG_RESIDUAL)
	Create a Tag.

void	addNotZeroedVectorTag (const TagID tag)
	Adds a vector tag to the list of vectors that will not be zeroed when other tagged vectors are.

bool	vectorTagNotZeroed (const TagID tag) const
	Checks if a vector tag is in the list of vectors that will not be zeroed when other tagged vectors are.

virtual const VectorTag &	getVectorTag (const TagID tag_id) const
	Get a VectorTag from a TagID.

std::vector< VectorTag >	getVectorTags (const std::set< TagID > &tag_ids) const

virtual const std::vector< VectorTag > &	getVectorTags (const Moose::VectorTagType type=Moose::VECTOR_TAG_ANY) const
	Return all vector tags, where a tag is represented by a map from name to ID.

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

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

virtual bool	vectorTagExists (const TagID tag_id) const
	Check to see if a particular Tag exists.

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

virtual unsigned int	numVectorTags (const Moose::VectorTagType type=Moose::VECTOR_TAG_ANY) const
	The total number of tags, which can be limited to the tag type.

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

virtual TagID	addMatrixTag (TagName tag_name)
	Create a Tag.

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

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

virtual bool	matrixTagExists (const TagName &tag_name) const
	Check to see if a particular Tag exists.

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

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

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

virtual bool	hasLinearVariable (const std::string &var_name) const
	Whether or not this problem has this linear variable.

virtual bool	hasAuxiliaryVariable (const std::string &var_name) const
	Whether or not this problem has this auxiliary variable.

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

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

Moose::CoordinateSystemType	getCoordSystem (SubdomainID sid) const

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

virtual DiracKernelInfo &	diracKernelInfo ()

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

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

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

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

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

void	reinitNeighborLowerDElem (const Elem *elem, const THREAD_ID tid=0)
	reinitialize a neighboring lower dimensional element

void	reinitMortarElem (const Elem *elem, const THREAD_ID tid=0)
	Reinit a mortar element to obtain a valid JxW.

void	reinitGeomSearch ()
	reinitialize this object's geometric search data, e.g.

virtual void	storeSubdomainMatPropName (SubdomainID block_id, const std::string &name)
	Adds the given material property to a storage map based on block ids.

virtual void	storeBoundaryMatPropName (BoundaryID boundary_id, const std::string &name)
	Adds the given material property to a storage map based on boundary ids.

virtual void	storeSubdomainZeroMatProp (SubdomainID block_id, const MaterialPropertyName &name)
	Adds to a map based on block ids of material properties for which a zero value can be returned.

virtual void	storeBoundaryZeroMatProp (BoundaryID boundary_id, const MaterialPropertyName &name)
	Adds to a map based on boundary ids of material properties for which a zero value can be returned.

virtual void	storeSubdomainDelayedCheckMatProp (const std::string &requestor, SubdomainID block_id, const std::string &name)
	Adds to a map based on block ids of material properties to validate.

virtual void	storeBoundaryDelayedCheckMatProp (const std::string &requestor, BoundaryID boundary_id, const std::string &name)
	Adds to a map based on boundary ids of material properties to validate.

virtual void	checkBlockMatProps ()
	Checks block material properties integrity.

virtual void	checkBoundaryMatProps ()
	Checks boundary material properties integrity.

virtual void	markMatPropRequested (const std::string &)
	Helper method for adding a material property name to the _material_property_requested set.

virtual bool	isMatPropRequested (const std::string &prop_name) const
	Find out if a material property has been requested by any object.

void	addConsumedPropertyName (const MooseObjectName &obj_name, const std::string &prop_name)
	Helper for tracking the object that is consuming a property for MaterialPropertyDebugOutput.

const std::map< MooseObjectName, std::set< std::string > > &	getConsumedPropertyMap () const
	Return the map that tracks the object with consumed material properties.

virtual std::set< SubdomainID >	getMaterialPropertyBlocks (const std::string &prop_name)
	Get a vector containing the block ids the material property is defined on.

virtual std::vector< SubdomainName >	getMaterialPropertyBlockNames (const std::string &prop_name)
	Get a vector of block id equivalences that the material property is defined on.

virtual bool	hasBlockMaterialProperty (SubdomainID block_id, const std::string &prop_name)
	Check if a material property is defined on a block.

virtual std::set< BoundaryID >	getMaterialPropertyBoundaryIDs (const std::string &prop_name)
	Get a vector containing the block ids the material property is defined on.

virtual std::vector< BoundaryName >	getMaterialPropertyBoundaryNames (const std::string &prop_name)
	Get a vector of block id equivalences that the material property is defined on.

virtual bool	hasBoundaryMaterialProperty (BoundaryID boundary_id, const std::string &prop_name)
	Check if a material property is defined on a block.

virtual std::set< dof_id_type > &	ghostedElems ()
	Return the list of elements that should have their DoFs ghosted to this processor.

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

void	setCurrentlyComputingJacobian (const bool currently_computing_jacobian)
	Set whether or not the problem is in the process of computing the Jacobian.

const bool &	currentlyComputingResidualAndJacobian () const
	Returns true if the problem is in the process of computing the residual and the Jacobian.

void	setCurrentlyComputingResidualAndJacobian (bool currently_computing_residual_and_jacobian)
	Set whether or not the problem is in the process of computing the Jacobian.

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

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

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

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

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

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

void	addAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf, bool to_mesh=true)
	Add an algebraic ghosting functor to this problem's DofMaps.

void	addCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf, bool to_mesh=true)
	Add a coupling functor to this problem's DofMaps.

void	removeAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf)
	Remove an algebraic ghosting functor from this problem's DofMaps.

void	removeCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf)
	Remove a coupling ghosting functor from this problem's DofMaps.

void	clearAllDofIndices ()
	Clear dof indices from variables in nl and aux systems.

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

bool	hasFunctor (const std::string &name, const THREAD_ID tid) const
	checks whether we have a functor corresponding to `name` on the thread id `tid`

template<typename T >
bool	hasFunctorWithType (const std::string &name, const THREAD_ID tid) const
	checks whether we have a functor of type T corresponding to `name` on the thread id `tid`

template<typename T >
void	addFunctor (const std::string &name, const Moose::FunctorBase< T > &functor, const THREAD_ID tid)
	add a functor to the problem functor container

template<typename T , typename PolymorphicLambda >
const Moose::FunctorBase< T > &	addPiecewiseByBlockLambdaFunctor (const std::string &name, PolymorphicLambda my_lammy, const std::set< ExecFlagType > &clearance_schedule, const MooseMesh &mesh, const std::set< SubdomainID > &block_ids, const THREAD_ID tid)
	Add a functor that has block-wise lambda definitions, e.g.

void	setFunctorOutput (bool set_output)
	Setter for debug functor output.

void	setChainControlDataOutput (bool set_output)
	Setter for debug chain control data output.

template<typename T >
void	registerUnfilledFunctorRequest (T *functor_interface, const std::string &functor_name, const THREAD_ID tid)
	Register an unfulfilled functor request.

void	reinitFVFace (const THREAD_ID tid, const FaceInfo &fi)
	reinitialize the finite volume assembly data for the provided face and thread

void	preparePRefinement ()
	Prepare `DofMap` and `Assembly` classes with our p-refinement information.

bool	doingPRefinement () const

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

void	_setCLIOption ()
	For Internal Use.

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

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

const ConsoleStream &	console () const
	Return console handle.

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

std::shared_ptr< MooseObject >	getSharedPtr ()
	Get another shared pointer to this object that has the same ownership group.

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

bool	isKokkosObject () const
	Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.

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

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

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

std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling.

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

MooseObjectName	uniqueName () const

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

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a parameter for the object.

template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
	Retrieve two parameters and provide pair of parameters for the object.

template<typename T >
const T *	queryParam (const std::string &name) const
	Query a parameter for the object.

template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object.

template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller.

bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid.

bool	isParamSetByUser (const std::string &name) const
	Test if the supplied parameter is set by a user, as opposed to not set or set to default.

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
	Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

template<typename... Args>
void	paramError (const std::string &param, Args... args) const
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const

template<typename... Args>
void	paramInfo (const std::string &param, Args... args) const
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

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

std::string	errorPrefix (const std::string &) const
	Deprecated message prefix; the error type is no longer used.

template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

template<typename... Args>
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

template<typename... Args>
void	mooseErrorNonPrefixed (Args &&... args) const
	Emits an error without the prefixing included in mooseError().

template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type.

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

template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
	Emits a warning without the prefixing included in mooseWarning().

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

template<typename... Args>
void	mooseDeprecated (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and a stack trace.

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

template<typename... Args>
void	mooseDeprecatedNoTrace (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and no stack trace.

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

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
	External method for calling moose error with added object context.

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

std::string	getDataFileName (const std::string &param) const
	Deprecated method.

std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method.

std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path.

PerfGraph &	perfGraph ()
	Get the PerfGraph.


const libMesh::ConstElemRange &	getEvaluableElementRange ()
	In general, {evaluable elements} >= {local elements} U {algebraic ghosting elements}.

const libMesh::ConstElemRange &	getNonlinearEvaluableElementRange ()


const libMesh::ConstElemRange &	getCurrentAlgebraicElementRange ()
	These are the element and nodes that contribute to the jacobian and residual for this local processor.

const libMesh::ConstNodeRange &	getCurrentAlgebraicNodeRange ()

const ConstBndNodeRange &	getCurrentAlgebraicBndNodeRange ()


void	setCurrentAlgebraicElementRange (libMesh::ConstElemRange *range)
	These functions allow setting custom ranges for the algebraic elements, nodes, and boundary nodes that contribute to the jacobian and residual for this local processor.

void	setCurrentAlgebraicNodeRange (libMesh::ConstNodeRange *range)

void	setCurrentAlgebraicBndNodeRange (ConstBndNodeRange *range)


void	allowOutput (bool state)
	Ability to enable/disable all output calls.

template<typename T >
void	allowOutput (bool state)


Moose::Kokkos::Array< Moose::Kokkos::System > &	getKokkosSystems ()
	Get the Kokkos System array (always populated when any Kokkos object exists)

const Moose::Kokkos::Array< Moose::Kokkos::System > &	getKokkosSystems () const


Moose::Kokkos::Array< Moose::Kokkos::FESystem > &	getKokkosFESystems ()
	Get the Kokkos FESystem array (populated only when FE Kokkos objects exist)

const Moose::Kokkos::Array< Moose::Kokkos::FESystem > &	getKokkosFESystems () const


Moose::Kokkos::System &	getKokkosSystem (const unsigned int sys_num)
	Get the Kokkos System of a specified number.

const Moose::Kokkos::System &	getKokkosSystem (const unsigned int sys_num) const


Moose::Kokkos::FESystem &	getKokkosFESystem (const unsigned int sys_num)
	Get the Kokkos FESystem of a specified number.

const Moose::Kokkos::FESystem &	getKokkosFESystem (const unsigned int sys_num) const


bool	hasMultiApps () const
	Returns whether or not the current simulation has any multiapps.

bool	hasMultiApps (ExecFlagType type) const

bool	hasMultiApp (const std::string &name) const


const AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced) const
	Return the undisplaced or displaced mortar generation object associated with the provided boundaries and subdomains.

AutomaticMortarGeneration &	getMortarInterface (const std::pair< BoundaryID, BoundaryID > &primary_secondary_boundary_pair, const std::pair< SubdomainID, SubdomainID > &primary_secondary_subdomain_pair, bool on_displaced)


const MaterialPropertyStorage &	getMaterialPropertyStorage ()
	Return a reference to the material property storage.

const MaterialPropertyStorage &	getBndMaterialPropertyStorage ()

const MaterialPropertyStorage &	getNeighborMaterialPropertyStorage ()

Moose::Kokkos::MaterialPropertyStorage &	getKokkosMaterialPropertyStorage ()

Moose::Kokkos::MaterialPropertyStorage &	getKokkosBndMaterialPropertyStorage ()

Moose::Kokkos::MaterialPropertyStorage &	getKokkosNeighborMaterialPropertyStorage ()


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

const MooseObjectWarehouse< InternalSideIndicatorBase > &	getInternalSideIndicatorWarehouse ()

const MooseObjectWarehouse< Marker > &	getMarkerWarehouse ()


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

bool	needInterfaceMaterialOnSide (BoundaryID bnd_id, const THREAD_ID tid)

bool	needInternalNeighborSideMaterial (SubdomainID subdomain_id, const THREAD_ID tid)


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

void	setCurrentExecuteOnFlag (const ExecFlagType &)

Static Public Member Functions
static InputParameters	validParams ()

static void	selectVectorTagsFromSystem (const SystemBase &system, const std::vector< VectorTag > &input_vector_tags, std::set< TagID > &selected_tags)
	Select the vector tags which belong to a specific system.

static void	selectMatrixTagsFromSystem (const SystemBase &system, const std::map< TagName, TagID > &input_matrix_tags, std::set< TagID > &selected_tags)
	Select the matrix tags which belong to a specific system.

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)
	External method for calling moose error with added object context.


template<typename T >
static void	objectSetupHelper (const std::vector< T * > &objects, const ExecFlagType &exec_flag)
	Helpers for calling the necessary setup/execute functions for the supplied objects.

template<typename T >
static void	objectExecuteHelper (const std::vector< T * > &objects)

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

	usingCombinedWarningSolutionWarnings

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


std::vector< Real >	_real_zero
	Convenience zeros.

std::vector< VariableValue >	_scalar_zero

std::vector< VariableValue >	_zero

std::vector< VariablePhiValue >	_phi_zero

std::vector< MooseArray< ADReal > >	_ad_zero

std::vector< VariableGradient >	_grad_zero

std::vector< MooseArray< ADRealVectorValue > >	_ad_grad_zero

std::vector< VariablePhiGradient >	_grad_phi_zero

std::vector< VariableSecond >	_second_zero

std::vector< MooseArray< ADRealTensorValue > >	_ad_second_zero

std::vector< VariablePhiSecond >	_second_phi_zero

std::vector< Point >	_point_zero

std::vector< VectorVariableValue >	_vector_zero

std::vector< VectorVariableCurl >	_vector_curl_zero

Static Public Attributes
static const std::string	type_param = "_type"
	The name of the parameter that contains the object type.

static const std::string	name_param = "_object_name"
	The name of the parameter that contains the object name.

static const std::string	unique_name_param = "_unique_name"
	The name of the parameter that contains the unique object name.

static const std::string	app_param = "_moose_app"
	The name of the parameter that contains the MooseApp.

static const std::string	moose_base_param = "_moose_base"
	The name of the parameter that contains the moose system base.

static const std::string	kokkos_object_param = "_kokkos_object"
	The name of the parameter that indicates an object is a Kokkos functor.

Protected Member Functions
virtual void	meshChanged ()
	Deprecated.

void	createTagVectors ()
	Create extra tagged vectors and matrices.

void	createTagSolutions ()
	Create extra tagged solution vectors.

virtual void	meshDisplaced ()
	Update data after a mesh displaced.

void	computeSystems (const ExecFlagType &type)
	Do generic system computations.

bool	duplicateVariableCheck (const std::string &var_name, const libMesh::FEType &type, bool is_aux, const std::set< SubdomainID > *const active_subdomains)
	Helper to check for duplicate variable names across systems or within a single system.

void	computeUserObjectsInternal (const ExecFlagType &type, TheWarehouse::Query &query)

void	computeKokkosUserObjectsInternal (const ExecFlagType &type, TheWarehouse::Query &query)

void	checkDisplacementOrders ()
	Verify that SECOND order mesh uses SECOND order displacements.

void	checkUserObjects ()

void	checkGradientMethods ()
	Let every FVGradientMethod resolve its dependencies on other gradient methods.

void	checkDependMaterialsHelper (const std::map< SubdomainID, std::vector< std::shared_ptr< MaterialBase > > > &materials_map)
	Helper method for checking Material object dependency.

void	checkCoordinateSystems ()
	Verify that there are no element type/coordinate type conflicts.

void	reinitBecauseOfGhostingOrNewGeomObjects (bool mortar_changed=false)
	Call when it is possible that the needs for ghosted elements has changed.

void	addObjectParamsHelper (InputParameters &params, const std::string &object_name, const std::string &var_param_name="variable")
	Helper for setting the "_subproblem" and "_sys" parameters in addObject() and in addUserObject().

template<typename T >
MooseVariableFieldBase &	getVariableHelper (const THREAD_ID tid, const std::string &var_name, Moose::VarKindType expected_var_type, Moose::VarFieldType expected_var_field_type, const std::vector< T > &nls, const SystemBase &aux) const
	Helper function called by getVariable that handles the logic for checking whether Variables of the requested type are available.

bool	verifyVectorTags () const
	Verify the integrity of _vector_tags and _typed_vector_tags.

template<bool warning>
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
	Set solution invalid mark for the given solution ID.

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

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

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing.

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

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

template<typename T , typename... Args>
ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declares a piece of "managed" restartable data and initialize it.

template<typename T , typename... Args>
const T &	getRestartableData (const std::string &data_name) const
	Declare a piece of data as "restartable" and initialize it Similar to `declareRestartableData` but returns a const reference to the object.

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

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

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

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

std::string	restartableName (const std::string &data_name) const
	Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

Protected Attributes
MooseMesh &	_mesh

bool	_initialized

std::optional< std::vector< ConvergenceName > >	_nonlinear_convergence_names
	Nonlinear system(s) convergence name(s)

std::optional< std::vector< ConvergenceName > >	_linear_convergence_names
	Linear system(s) convergence name(s) (if any)

std::optional< ConvergenceName >	_multiapp_fixed_point_convergence_name
	MultiApp fixed point convergence name.

std::optional< ConvergenceName >	_steady_state_convergence_name
	Steady-state detection convergence name.

std::set< TagID >	_fe_vector_tags

std::set< TagID >	_fe_matrix_tags

std::set< TagID >	_linear_vector_tags
	Temporary storage for filtered vector tags for linear systems.

std::set< TagID >	_linear_matrix_tags
	Temporary storage for filtered matrix tags for linear systems.

const bool &	_solve
	Whether or not to actually solve the nonlinear system.

bool	_transient

Real &	_time

Real &	_time_old

Real &	_time_older

int &	_t_step

Real &	_dt

Real &	_dt_old

bool	_need_to_add_default_nonlinear_convergence
	Flag that the problem needs to add the default nonlinear convergence.

bool	_need_to_add_default_multiapp_fixed_point_convergence
	Flag that the problem needs to add the default fixed point convergence.

bool	_need_to_add_default_steady_state_convergence
	Flag that the problem needs to add the default steady convergence.

const std::vector< LinearSystemName >	_linear_sys_names
	The linear system names.

const std::size_t	_num_linear_sys
	The number of linear systems.

std::vector< std::shared_ptr< LinearSystem > >	_linear_systems
	The vector of linear systems.

std::map< LinearSystemName, unsigned int >	_linear_sys_name_to_num
	Map from linear system name to number.

LinearSystem *	_current_linear_sys
	The current linear system that we are solving.

const bool	_using_default_nl
	Boolean to check if we have the default nonlinear system.

const std::vector< NonlinearSystemName >	_nl_sys_names
	The nonlinear system names.

const std::size_t	_num_nl_sys
	The number of nonlinear systems.

std::vector< std::shared_ptr< NonlinearSystemBase > >	_nl
	The nonlinear systems.

std::map< NonlinearSystemName, unsigned int >	_nl_sys_name_to_num
	Map from nonlinear system name to number.

NonlinearSystemBase *	_current_nl_sys
	The current nonlinear system that we are solving.

SolverSystem *	_current_solver_sys
	The current solver system.

std::vector< std::shared_ptr< SolverSystem > >	_solver_systems
	Combined container to base pointer of every solver system.

std::map< SolverVariableName, unsigned int >	_solver_var_to_sys_num
	Map connecting variable names with their respective solver systems.

std::map< SolverSystemName, unsigned int >	_solver_sys_name_to_num
	Map connecting solver system names with their respective systems.

std::vector< SolverSystemName >	_solver_sys_names
	The union of nonlinear and linear system names.

std::shared_ptr< AuxiliarySystem >	_aux
	The auxiliary system.

Moose::CouplingType	_coupling
	Type of variable coupling.

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

Moose::Kokkos::Array< Moose::Kokkos::System >	_kokkos_systems
	System array - sparsely populated (only slots for systems needing a Kokkos::System)

Moose::Kokkos::Array< Moose::Kokkos::FESystem >	_kokkos_fe_systems
	FESystem array - sparsely populated (only slots for systems needing a Kokkos::FESystem)

std::map< std::string, unsigned int >	_subspace_dim
	Dimension of the subspace spanned by the vectors with a given prefix.

std::vector< std::vector< std::unique_ptr< Assembly > > >	_assembly
	The Assembly objects.

Moose::Kokkos::Assembly	_kokkos_assembly

MooseObjectWarehouse< MeshDivision >	_mesh_divisions
	Warehouse to store mesh divisions NOTE: this could probably be moved to the MooseMesh instead of the Problem Time (and people's uses) will tell where this fits best.

MooseObjectWarehouse< Function >	_functions
	functions

MooseObjectWarehouse< Moose::FunctionBase >	_kokkos_functions

MooseObjectWarehouse< Convergence >	_convergences
	convergence warehouse

MooseObjectWarehouse< KernelBase >	_nonlocal_kernels
	nonlocal kernels

MooseObjectWarehouse< IntegratedBCBase >	_nonlocal_integrated_bcs
	nonlocal integrated_bcs

MaterialPropertyRegistry	_material_prop_registry

MaterialPropertyStorage &	_material_props

MaterialPropertyStorage &	_bnd_material_props

MaterialPropertyStorage &	_neighbor_material_props

Moose::Kokkos::MaterialPropertyStorage &	_kokkos_material_props

Moose::Kokkos::MaterialPropertyStorage &	_kokkos_bnd_material_props

Moose::Kokkos::MaterialPropertyStorage &	_kokkos_neighbor_material_props

MooseObjectWarehouse< Marker >	_markers

ReporterData	_reporter_data

ExecuteMooseObjectWarehouse< MultiApp >	_multi_apps
	MultiApp Warehouse.

ExecuteMooseObjectWarehouse< TransientMultiApp >	_transient_multi_apps
	Storage for TransientMultiApps (only needed for calling 'computeDT')

ExecuteMooseObjectWarehouse< Transfer >	_transfers
	Normal Transfers.

ExecuteMooseObjectWarehouse< Transfer >	_to_multi_app_transfers
	Transfers executed just before MultiApps to transfer data to them.

ExecuteMooseObjectWarehouse< Transfer >	_from_multi_app_transfers
	Transfers executed just after MultiApps to transfer data from them.

ExecuteMooseObjectWarehouse< Transfer >	_between_multi_app_transfers
	Transfers executed just before MultiApps to transfer data between them.

const unsigned int	_num_concurrent_multiapps
	Number of concurrent applications being solved at the same time.

std::map< std::string, std::unique_ptr< RandomData > >	_random_data_objects
	A map of objects that consume random numbers.

std::vector< std::unordered_map< SubdomainID, bool > >	_block_mat_side_cache
	Cache for calculating materials on side.

std::vector< std::unordered_map< BoundaryID, bool > >	_bnd_mat_side_cache
	Cache for calculating materials on side.

std::vector< std::unordered_map< BoundaryID, bool > >	_interface_mat_side_cache
	Cache for calculating materials on interface.

std::vector< MeshChangedInterface * >	_notify_when_mesh_changes
	Objects to be notified when the mesh changes.

std::vector< MeshDisplacedInterface * >	_notify_when_mesh_displaces
	Objects to be notified when the mesh displaces.

Adaptivity	_adaptivity

unsigned int	_cycles_completed

std::shared_ptr< XFEMInterface >	_xfem
	Pointer to XFEM controller.

MooseMesh *	_displaced_mesh

std::shared_ptr< DisplacedProblem >	_displaced_problem

GeometricSearchData	_geometric_search_data

std::unique_ptr< MortarInterfaceWarehouse >	_mortar_data

bool	_reinit_displaced_elem
	Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.

bool	_reinit_displaced_face
	Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.

bool	_reinit_displaced_neighbor
	Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.

bool	_input_file_saved
	whether input file has been written

bool	_has_dampers
	Whether or not this system has any Dampers associated with it.

bool	_has_constraints
	Whether or not this system has any Constraints.

bool	_snesmf_reuse_base
	If or not to resuse the base vector for matrix-free calculation.

bool	_skip_exception_check
	If or not skip 'exception and stop solve'.

bool	_snesmf_reuse_base_set_by_user
	If or not _snesmf_reuse_base is set by user.

bool	_has_initialized_stateful
	Whether nor not stateful materials have been initialized.

bool	_const_jacobian
	true if the Jacobian is constant

bool	_has_jacobian
	Indicates if the Jacobian was computed.

bool	_needs_old_newton_iter
	Indicates that we need to compute variable values for previous Newton iteration.

bool	_previous_nl_solution_required
	Indicates we need to save the previous NL iteration variable values.

std::vector< bool >	_previous_multiapp_fp_nl_solution_required
	Indicates we need to save the previous multiapp fixed-point iteration solver variable values.

bool	_previous_multiapp_fp_aux_solution_required
	Indicates we need to save the previous multiapp fixed-point iteration auxiliary variable values.

std::vector< bool >	_previous_multisystem_fp_nl_solution_required
	Indicates we need to save the previous multi-system fixed-point iteration solver variable values.

bool	_previous_multisystem_fp_aux_solution_required
	Indicates we need to save the previous multi-system fixed-point iteration auxiliary variable values.

bool	_has_nonlocal_coupling
	Indicates if nonlocal coupling is required/exists.

bool	_calculate_jacobian_in_uo

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

std::vector< unsigned char >	_has_active_material_properties
	Whether there are active material properties on each thread.

std::vector< SolverParams >	_solver_params

CoverageCheckMode	_kernel_coverage_check
	Determines whether and which subdomains are to be checked to ensure that they have an active kernel.

std::vector< SubdomainName >	_kernel_coverage_blocks

const bool	_boundary_restricted_node_integrity_check
	whether to perform checking of boundary restricted nodal object variable dependencies, e.g.

const bool	_boundary_restricted_elem_integrity_check
	whether to perform checking of boundary restricted elemental object variable dependencies, e.g.

const bool	_side_uo_interface_mat_prop_integrity_check
	Whether to check that side user objects do not consume interface material properties.

CoverageCheckMode	_material_coverage_check
	Determines whether and which subdomains are to be checked to ensure that they have an active material.

std::vector< SubdomainName >	_material_coverage_blocks

bool	_fv_bcs_integrity_check
	Whether to check overlapping Dirichlet and Flux BCs and/or multiple DirichletBCs per sideset.

const bool	_fv_face_integrity_check
	Whether to check FV boundary and interface objects against the faces on which they execute.

const bool	_material_dependency_check
	Determines whether a check to verify material dependencies on every subdomain.

const bool	_uo_aux_state_check
	Whether or not checking the state of uo/aux evaluation.

bool	_check_residual_for_nans
	Whether to check the residual for NaN or Inf values.

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

libMesh::Order	_max_scalar_order
	Maximum scalar variable order.

bool	_has_time_integrator
	Indicates whether or not this executioner has a time integrator (during setup)

bool	_has_exception
	Whether or not an exception has occurred.

bool	_parallel_barrier_messaging
	Whether or not information about how many transfers have completed is printed.

MooseEnum	_verbose_setup
	Whether or not to be verbose during setup.

bool	_verbose_multiapps
	Whether or not to be verbose with multiapps.

bool	_verbose_restore
	Whether or not to be verbose on solution restoration post a failed time step.

std::string	_exception_message
	The error message to go with an exception.

ExecFlagType	_current_execute_on_flag
	Current execute_on flag.

ExecuteMooseObjectWarehouse< Control >	_control_warehouse
	The control logic warehouse.

Moose::PetscSupport::PetscOptions	_petsc_options
	PETSc option storage.

PetscOptions	_petsc_option_data_base

bool	_is_petsc_options_inserted
	If or not PETSc options have been added to database.

std::shared_ptr< LineSearch >	_line_search

std::unique_ptr< libMesh::ConstElemRange >	_evaluable_local_elem_range

std::unique_ptr< libMesh::ConstElemRange >	_nl_evaluable_local_elem_range

std::unique_ptr< libMesh::ConstElemRange >	_aux_evaluable_local_elem_range

std::unique_ptr< libMesh::ConstElemRange >	_current_algebraic_elem_range

std::unique_ptr< libMesh::ConstNodeRange >	_current_algebraic_node_range

std::unique_ptr< ConstBndNodeRange >	_current_algebraic_bnd_node_range

bool	_using_ad_mat_props
	Automatic differentiaion (AD) flag which indicates whether any consumer has requested an AD material property or whether any suppier has declared an AD material property.

unsigned short	_current_ic_state

const bool	_use_hash_table_matrix_assembly
	Whether to assemble matrices using hash tables instead of preallocating matrix memory.

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

std::map< TagID, TagName >	_matrix_tag_id_to_tag_name
	Reverse map.

Factory &	_factory
	The Factory for building objects.

DiracKernelInfo	_dirac_kernel_info

std::map< SubdomainID, std::set< std::string > >	_map_block_material_props
	Map of material properties (block_id -> list of properties)

std::map< BoundaryID, std::set< std::string > >	_map_boundary_material_props
	Map for boundary material properties (boundary_id -> list of properties)

std::map< SubdomainID, std::set< MaterialPropertyName > >	_zero_block_material_props
	Set of properties returned as zero properties.

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

std::set< std::string >	_material_property_requested
	set containing all material property names that have been requested by getMaterialProperty*

std::vector< std::set< MooseVariableFieldBase * > >	_active_elemental_moose_variables
	This is the set of MooseVariableFieldBase that will actually get reinited by a call to reinit(elem)

std::vector< unsigned int >	_has_active_elemental_moose_variables
	Whether or not there is currently a list of active elemental moose variables.

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

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

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

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

bool	_default_ghosting
	Whether or not to use default libMesh coupling.

std::set< dof_id_type >	_ghosted_elems
	Elements that should have Dofs ghosted to the local processor.

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

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

bool	_computing_nonlinear_residual
	Whether the non-linear residual is being evaluated.

bool	_currently_computing_residual
	Whether the residual is being evaluated.

bool	_safe_access_tagged_matrices
	Is it safe to retrieve data from tagged matrices.

bool	_safe_access_tagged_vectors
	Is it safe to retrieve data from tagged vectors.

bool	_have_ad_objects
	AD flag indicating whether any AD objects have been added.

std::unordered_set< TagID >	_not_zeroed_tagged_vectors
	the list of vector tags that will not be zeroed when all other tags are

bool	_cli_option_found
	True if the CLI option is found.

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

bool	_termination_requested
	True if termination of the solve has been requested.

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

MooseApp &	_app
	The MOOSE application this is associated with.

ActionFactory &	_action_factory
	Builds Actions.

const std::string &	_type
	The type of this class.

const std::string &	_name
	The name of this class.

const InputParameters &	_pars
	The object's parameters.

const Parallel::Communicator &	_communicator

MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph.

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

MooseApp &	_restartable_app
	Reference to the application.

const std::string	_restartable_system_name
	The system name this object is in.

const THREAD_ID	_restartable_tid
	The thread ID for this object.

const bool	_restartable_read_only
	Flag for toggling read only status (see ReporterData)


InitialConditionWarehouse	_ics

FVInitialConditionWarehouse	_fv_ics

ScalarInitialConditionWarehouse	_scalar_ics


MaterialWarehouse	_materials

MaterialWarehouse	_interface_materials

MaterialWarehouse	_discrete_materials

MaterialWarehouse	_all_materials

MaterialWarehouse	_kokkos_materials


MooseObjectWarehouse< Indicator >	_indicators

MooseObjectWarehouse< InternalSideIndicatorBase >	_internal_side_indicators


std::map< SubdomainID, std::multimap< std::string, std::string > >	_map_block_material_props_check
	Data structures of the requested material properties.

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

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

Private Member Functions
void	setResidualObjectParamsAndLog (const std::string &ro_name, const std::string &name, InputParameters &parameters, const unsigned int nl_sys_num, const std::string &base_name, bool &reinit_displaced)
	Set the subproblem and system parameters for residual objects and log their addition.

void	setAuxKernelParamsAndLog (const std::string &ak_name, const std::string &name, InputParameters &parameters, const std::string &base_name)
	Set the subproblem and system parameters for auxiliary kernels and log their addition.

TheWarehouse::Query	getUOQuery (const std::string &system, const ExecFlagType &type, const Moose::AuxGroup &group) const

void	getUOExecutionGroups (TheWarehouse::Query &query, std::set< int > &execution_groups) const

void	handleException (const std::string &calling_method)
	Handle exceptions.

std::vector< MortarUserObject * >	getMortarUserObjects (BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced, const std::vector< MortarUserObject * > &mortar_uo_superset)
	Helper for getting mortar objects corresponding to primary boundary ID, secondary boundary ID, and displaced parameters, given some initial set.

std::vector< MortarUserObject * >	getMortarUserObjects (BoundaryID primary_boundary_id, BoundaryID secondary_boundary_id, bool displaced)
	Helper for getting mortar objects corresponding to primary boundary ID, secondary boundary ID, and displaced parameters from the entire active mortar user object set.

virtual std::pair< bool, unsigned int >	determineSolverSystem (const std::string &var_name, bool error_if_not_found=false) const override
	Determine what solver system the provided variable name lies in.

void	checkICRestartError (const std::string &ic_name, const std::string &name, const VariableName &var_name)
	Checks if the variable of the initial condition is getting restarted and errors for specific cases.

void	addAnyRedistributers ()

void	updateMaxQps ()

void	joinAndFinalize (TheWarehouse::Query query, bool isgen=false)

void	kokkosJoinAndFinalize (const std::vector< Moose::Kokkos::UserObject * > &userobjs)

virtual void	resetState ()
	Reset state of this object in preparation for the next evaluation.

void	cloneAlgebraicGhostingFunctor (libMesh::GhostingFunctor &algebraic_gf, bool to_mesh=true)
	Creates (n_sys - 1) clones of the provided algebraic ghosting functor (corresponding to the nonlinear system algebraic ghosting functor), initializes the clone with the appropriate DofMap, and then adds the clone to said DofMap.

void	cloneCouplingGhostingFunctor (libMesh::GhostingFunctor &coupling_gf, bool to_mesh=true)
	Creates (n_sys - 1) clones of the provided coupling ghosting functor (corresponding to the nonlinear system coupling ghosting functor), initializes the clone with the appropriate DofMap, and then adds the clone to said DofMap.

void	showFunctors () const
	Lists all functors in the problem.

void	showFunctorRequestors () const
	Lists all functors and all the objects that requested them.

RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const
	Helper function for actually registering the restartable data.

void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)
	Helper function for actually registering the restartable data.

template<typename T , typename... Args>
RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const
	Helper function for declaring restartable data.


std::string	restrictionSubdomainCheckName (SubdomainID check_id)
	Helper functions for checking MaterialProperties.

std::string	restrictionBoundaryCheckName (BoundaryID check_id)

Static Private Member Functions
static SolverParams	makeLinearSolverParams ()
	Make basic solver params for linear solves.

static const hit::Node *	getHitNode (const InputParameters &params)
	Internal method for getting a hit node (if available) given a set of parameters.

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)
	Internal method for getting the message prefix for an object (object type, name, etc).

Private Attributes
Restartable::ManagedValue< RestartableEquationSystems >	_req
	The EquationSystems object, wrapped for restart.

bool	_error_on_jacobian_nonzero_reallocation
	Whether to error when the Jacobian is re-allocated, usually because the sparsity pattern changed.

const bool	_restore_original_nonzero_pattern
	Whether we should restore the original nonzero pattern for every Jacobian evaluation.

bool	_ignore_zeros_in_jacobian
	Whether to ignore zeros in the Jacobian, thereby leading to a reduced sparsity pattern.

bool	_preserve_matrix_sparsity_pattern
	Whether to preserve the system matrix / Jacobian sparsity pattern, using 0-valued entries usually.

const bool	_force_restart

const bool	_allow_ics_during_restart

const bool	_skip_nl_system_check

bool	_fail_next_system_convergence_check

const bool	_allow_invalid_solution

const bool	_show_invalid_solution_console

const bool &	_immediately_print_invalid_solution

bool	_started_initial_setup
	At or beyond initialSteup stage.

bool	_has_internal_edge_residual_objects
	Whether the problem has dgkernels or interface kernels.

bool	_u_dot_requested
	Whether solution time derivative needs to be stored.

bool	_u_dotdot_requested
	Whether solution second time derivative needs to be stored.

bool	_u_dot_old_requested
	Whether old solution time derivative needs to be stored.

bool	_u_dotdot_old_requested
	Whether old solution second time derivative needs to be stored.

bool	_has_mortar
	Whether the simulation requires mortar coupling.

unsigned int	_num_grid_steps
	Number of steps in a grid sequence.

bool	_trust_user_coupling_matrix = false
	Whether to trust the user coupling matrix no matter what.

bool	_computing_scaling_jacobian = false
	Flag used to indicate whether we are computing the scaling Jacobian.

bool	_computing_scaling_residual = false
	Flag used to indicate whether we are computing the scaling Residual.

bool	_checking_uo_aux_state = false
	Flag used to indicate whether we are doing the uo/aux state check in execute.

ExecFlagEnum	_print_execution_on
	When to print the execution of loops.

const bool	_identify_variable_groups_in_nl
	Whether to identify variable groups in nonlinear systems. This affects dof ordering.

std::vector< VectorTag >	_current_residual_vector_tags
	A data member to store the residual vector tag(s) passed into `computeResidualTag(s)`.

bool	_have_fv = false
	Whether we are performing some calculations with finite volume discretizations.

const bool	_regard_general_exceptions_as_errors
	If we catch an exception during residual/Jacobian evaluaton for which we don't have specific handling, immediately error instead of allowing the time step to be cut.

std::vector< libMesh::CouplingMatrix >	_nonlocal_cm
	nonlocal coupling matrix

bool	_requires_nonlocal_coupling
	nonlocal coupling requirement flag

bool	_has_kokkos_objects = false
	Whether we have any Kokkos objects.

bool	_has_kokkos_residual_objects = false
	Whether we have any Kokkos residual objects.

std::vector< std::function< void()> >	_kokkos_mesh_initialization_hooks
	Container holding hooks for functions that need to be called after Kokkos mesh initialization.

std::vector< std::multimap< std::string, std::tuple< TrueFunctorIs, std::unique_ptr< Moose::FunctorEnvelopeBase >, std::unique_ptr< Moose::FunctorEnvelopeBase > > > >	_functors
	A container holding pointers to all the functors in our problem.

std::vector< std::map< std::string, std::unique_ptr< Moose::FunctorAbstract > > >	_pbblf_functors
	Container to hold PiecewiseByBlockLambdaFunctors.

std::map< std::string, std::set< std::string > >	_functor_to_requestors
	The requestors of functors where the key is the prop name and the value is a set of names of requestors.

std::vector< std::multimap< std::string, std::pair< bool, bool > > >	_functor_to_request_info
	A multimap (for each thread) from unfilled functor requests to whether the requests were for AD functors and whether the requestor was an AD object.

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

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

std::vector< VectorTag >	_vector_tags
	The declared vector tags.

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

std::map< TagName, TagID >	_vector_tags_name_map
	Map of vector tag TagName to TagID.

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

std::unordered_map< libMesh::GhostingFunctor *, std::vector< std::shared_ptr< libMesh::GhostingFunctor > > >	_root_alg_gf_to_sys_clones
	A map from a root algebraic ghosting functor, e.g.

std::unordered_map< libMesh::GhostingFunctor *, std::vector< std::shared_ptr< libMesh::GhostingFunctor > > >	_root_coupling_gf_to_sys_clones
	A map from a root coupling ghosting functor, e.g.

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base
	The MooseBase that owns this interface.

const FEProblemBase *	_si_problem
	A pointer to FEProblem base.

const RestartableDataMapName	_metaname
	Restartable metadata name.

std::string	_restartable_name
	The name of the object.

Friends
class	AuxiliarySystem

class	NonlinearSystemBase

class	MooseEigenSystem

class	Resurrector

class	Restartable

class	DisplacedProblem

void	Moose::PetscSupport::setSinglePetscOption (const std::string &name, const std::string &value, FEProblemBase *const problem)

Detailed Description

Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.

Definition at line 158 of file FEProblemBase.h.

Member Typedef Documentation

◆ DataFileParameterType

using DataFileInterface::DataFileParameterType = DataFileName

inherited

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

Definition at line 27 of file DataFileInterface.h.

Member Enumeration Documentation

◆ CoverageCheckMode

enum class FEProblemBase::CoverageCheckMode

strong

Enumerator
FALSE
TRUE
OFF
ON
SKIP_LIST
ONLY_LIST

Definition at line 171 of file FEProblemBase.h.

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

◆ TrueFunctorIs

enum class SubProblem::TrueFunctorIs

strongprivateinherited

Enumerator
UNSET
NONAD
AD

Definition at line 1130 of file SubProblem.h.

  {
    UNSET,
    NONAD,
    AD
  };

Constructor & Destructor Documentation

◆ FEProblemBase()

FEProblemBase::FEProblemBase ( const InputParameters & parameters )

Definition at line 422 of file FEProblemBase.C.

  : SubProblem(parameters),
    Restartable(this, "FEProblemBase"),
    _mesh(*getCheckedPointerParam<MooseMesh *>("mesh")),
    _req(declareManagedRestartableDataWithContext<RestartableEquationSystems>(
        "equation_systems", nullptr, _mesh)),
    _initialized(false),
    _solve(getParam<bool>("solve")),
    _transient(false),
    _time(declareRestartableData<Real>("time")),
    _time_old(declareRestartableData<Real>("time_old")),
    _time_older(declareRestartableData<Real>("time_older")),
    _t_step(declareRecoverableData<int>("t_step")),
    _dt(declareRestartableData<Real>("dt")),
    _dt_old(declareRestartableData<Real>("dt_old")),
    _need_to_add_default_nonlinear_convergence(false),
    _need_to_add_default_multiapp_fixed_point_convergence(false),
    _need_to_add_default_steady_state_convergence(false),
    _linear_sys_names(getParam<std::vector<LinearSystemName>>("linear_sys_names")),
    _num_linear_sys(_linear_sys_names.size()),
    _linear_systems(_num_linear_sys, nullptr),
    _current_linear_sys(nullptr),
    _using_default_nl(!isParamSetByUser("nl_sys_names")),
    _nl_sys_names(!_using_default_nl || (_using_default_nl && !_linear_sys_names.size())
                      ? getParam<std::vector<NonlinearSystemName>>("nl_sys_names")
                      : std::vector<NonlinearSystemName>()),
    _num_nl_sys(_nl_sys_names.size()),
    _nl(_num_nl_sys, nullptr),
    _current_nl_sys(nullptr),
    _solver_systems(_num_nl_sys + _num_linear_sys, nullptr),
    _aux(nullptr),
    _coupling(Moose::COUPLING_DIAG),
#ifdef MOOSE_KOKKOS_ENABLED
    _kokkos_assembly(*this),
#endif
    _mesh_divisions(numThreads()),
    _functions(numThreads()),
#ifdef MOOSE_KOKKOS_ENABLED
    _kokkos_functions(numThreads()),
#endif
    _convergences(numThreads()),
    _nonlocal_kernels(numThreads()),
    _nonlocal_integrated_bcs(numThreads()),
    _ics(numThreads()),
    _fv_ics(numThreads()),
    _material_props(declareRestartableDataWithContext<MaterialPropertyStorage>(
        "material_props", &_mesh, _material_prop_registry, *this)),
    _bnd_material_props(declareRestartableDataWithContext<MaterialPropertyStorage>(
        "bnd_material_props", &_mesh, _material_prop_registry, *this)),
    _neighbor_material_props(declareRestartableDataWithContext<MaterialPropertyStorage>(
        "neighbor_material_props", &_mesh, _material_prop_registry, *this)),
#ifdef MOOSE_KOKKOS_ENABLED
    _kokkos_material_props(
        declareRestartableDataWithContext<Moose::Kokkos::MaterialPropertyStorage>(
            "kokkos_material_props", &_mesh, _material_prop_registry, *this)),
    _kokkos_bnd_material_props(
        declareRestartableDataWithContext<Moose::Kokkos::MaterialPropertyStorage>(
            "kokkos_bnd_material_props", &_mesh, _material_prop_registry, *this)),
    _kokkos_neighbor_material_props(
        declareRestartableDataWithContext<Moose::Kokkos::MaterialPropertyStorage>(
            "kokkos_neighbor_material_props", &_mesh, _material_prop_registry, *this)),
#endif
    _materials(numThreads()),
    _interface_materials(numThreads()),
    _discrete_materials(numThreads()),
    _all_materials(numThreads()),
#ifdef MOOSE_KOKKOS_ENABLED
    _kokkos_materials(numThreads()),
#endif
    _indicators(numThreads()),
    _internal_side_indicators(numThreads()),
    _markers(numThreads()),
    _reporter_data(_app),
    _multi_apps(_app.getExecuteOnEnum(), numThreads()),
    _transient_multi_apps(_app.getExecuteOnEnum(), numThreads()),
    _transfers(_app.getExecuteOnEnum(), /*num_threads=*/1),
    _to_multi_app_transfers(_app.getExecuteOnEnum(), /*num_threads=*/1),
    _from_multi_app_transfers(_app.getExecuteOnEnum(), /*num_threads=*/1),
    _between_multi_app_transfers(_app.getExecuteOnEnum(), /*num_threads=*/1),
    _num_concurrent_multiapps(getParam<unsigned int>("num_concurrent_multiapps")),
#ifdef LIBMESH_ENABLE_AMR
    _adaptivity(*this),
    _cycles_completed(0),
#endif
    _displaced_mesh(nullptr),
    _geometric_search_data(*this, _mesh),
    _mortar_data(std::make_unique<MortarInterfaceWarehouse>(*this)),
    _reinit_displaced_elem(false),
    _reinit_displaced_face(false),
    _reinit_displaced_neighbor(false),
    _input_file_saved(false),
    _has_dampers(false),
    _has_constraints(false),
    _snesmf_reuse_base(true),
    _skip_exception_check(false),
    _snesmf_reuse_base_set_by_user(false),
    _has_initialized_stateful(false),
    _const_jacobian(false),
    _has_jacobian(false),
    _needs_old_newton_iter(false),
    _previous_nl_solution_required(getParam<bool>("previous_nl_solution_required")),
    _previous_multiapp_fp_nl_solution_required(_num_nl_sys + _num_linear_sys, false),
    _previous_multiapp_fp_aux_solution_required(false),
    _previous_multisystem_fp_nl_solution_required(_num_nl_sys + _num_linear_sys, false),
    _previous_multisystem_fp_aux_solution_required(false),
    _has_nonlocal_coupling(false),
    _calculate_jacobian_in_uo(false),
    _kernel_coverage_check(
        getParam<MooseEnum>("kernel_coverage_check").getEnum<CoverageCheckMode>()),
    _kernel_coverage_blocks(getParam<std::vector<SubdomainName>>("kernel_coverage_block_list")),
    _boundary_restricted_node_integrity_check(
        getParam<bool>("boundary_restricted_node_integrity_check")),
    _boundary_restricted_elem_integrity_check(
        getParam<bool>("boundary_restricted_elem_integrity_check")),
    _side_uo_interface_mat_prop_integrity_check(
        getParam<bool>("side_uo_interface_mat_prop_integrity_check")),
    _material_coverage_check(
        getParam<MooseEnum>("material_coverage_check").getEnum<CoverageCheckMode>()),
    _material_coverage_blocks(getParam<std::vector<SubdomainName>>("material_coverage_block_list")),
    _fv_bcs_integrity_check(getParam<bool>("fv_bcs_integrity_check")),
    _fv_face_integrity_check(getParam<bool>("fv_face_integrity_check")),
    _material_dependency_check(getParam<bool>("material_dependency_check")),
    _uo_aux_state_check(getParam<bool>("check_uo_aux_state")),
#ifndef NDEBUG
    _check_residual_for_nans(false),
#endif
    _max_qps(std::numeric_limits<unsigned int>::max()),
    _max_scalar_order(INVALID_ORDER),
    _has_time_integrator(false),
    _has_exception(false),
    _parallel_barrier_messaging(getParam<bool>("parallel_barrier_messaging")),
    _verbose_setup(getParam<MooseEnum>("verbose_setup")),
    _verbose_multiapps(getParam<bool>("verbose_multiapps")),
    _verbose_restore(getParam<bool>("verbose_restore")),
    _current_execute_on_flag(EXEC_NONE),
    _control_warehouse(_app.getExecuteOnEnum(), /*num_threads=*/1),
    _is_petsc_options_inserted(false),
    _line_search(nullptr),
    _using_ad_mat_props(false),
    _current_ic_state(0),
    _use_hash_table_matrix_assembly(getParam<bool>("use_hash_table_matrix_assembly")),
    _error_on_jacobian_nonzero_reallocation(
        isParamValid("error_on_jacobian_nonzero_reallocation")
            ? getParam<bool>("error_on_jacobian_nonzero_reallocation")
            : _app.errorOnJacobianNonzeroReallocation()),
    _restore_original_nonzero_pattern(isParamValid("restore_original_nonzero_pattern")
                                          ? getParam<bool>("restore_original_nonzero_pattern")
                                          : _use_hash_table_matrix_assembly),
    _ignore_zeros_in_jacobian(getParam<bool>("ignore_zeros_in_jacobian")),
    _preserve_matrix_sparsity_pattern(true),
    _force_restart(getParam<bool>("force_restart")),
    _allow_ics_during_restart(getParam<bool>("allow_initial_conditions_with_restart")),
    _skip_nl_system_check(getParam<bool>("skip_nl_system_check")),
    _fail_next_system_convergence_check(false),
    _allow_invalid_solution(getParam<bool>("allow_invalid_solution")),
    _show_invalid_solution_console(getParam<bool>("show_invalid_solution_console")),
    _immediately_print_invalid_solution(getParam<bool>("immediately_print_invalid_solution")),
    _started_initial_setup(false),
    _has_internal_edge_residual_objects(false),
    _u_dot_requested(false),
    _u_dotdot_requested(false),
    _u_dot_old_requested(false),
    _u_dotdot_old_requested(false),
    _has_mortar(false),
    _num_grid_steps(0),
    _print_execution_on(),
    _identify_variable_groups_in_nl(getParam<bool>("identify_variable_groups_in_nl")),
    _regard_general_exceptions_as_errors(getParam<bool>("regard_general_exceptions_as_errors")),
    _requires_nonlocal_coupling(false)
{
  auto checkCoverageCheckConflict =
      [this](const std::string & coverage_check,
             const CoverageCheckMode & coverage_check_mode,
             const std::vector<SubdomainName> & coverage_blocks) -> void
  {
    if (coverage_check_mode != CoverageCheckMode::FALSE &&
        coverage_check_mode != CoverageCheckMode::OFF)
      if (coverage_blocks.size() > 1)
        if (std::find(coverage_blocks.begin(), coverage_blocks.end(), "ANY_BLOCK_ID") !=
            coverage_blocks.end())
          paramError(coverage_check,
                     "The list of blocks used for ",
                     coverage_check,
                     " cannot contain 'ANY_BLOCK_ID' along with other blocks. ");
  };
 
  checkCoverageCheckConflict(
      "kernel_coverage_check", _kernel_coverage_check, _kernel_coverage_blocks);
  checkCoverageCheckConflict(
      "material_coverage_check", _material_coverage_check, _material_coverage_blocks);
 
  //  Initialize static do_derivatives member. We initialize this to true so that all the
  //  default AD things that we setup early in the simulation actually get their derivative
  //  vectors initalized. We will toggle this to false when doing residual evaluations
  ADReal::do_derivatives = true;
 
  // Disable refinement/coarsening in EquationSystems::reinit because we already do this ourselves
  es().disable_refine_in_reinit();
 
  _solver_params.reserve(_num_nl_sys + _num_linear_sys);
  // Default constructor fine for nonlinear because it will be populated later by framework
  // executioner/solve object parameters
  _solver_params.resize(_num_nl_sys);
  for (const auto i : index_range(_nl_sys_names))
  {
    const auto & name = _nl_sys_names[i];
    _nl_sys_name_to_num[name] = i;
    _solver_sys_name_to_num[name] = i;
    _solver_sys_names.push_back(name);
  }
 
  for (const auto i : index_range(_linear_sys_names))
  {
    const auto & name = _linear_sys_names[i];
    _linear_sys_name_to_num[name] = i;
    _solver_sys_name_to_num[name] = i + _num_nl_sys;
    _solver_sys_names.push_back(name);
    // Unlike for nonlinear these are basically dummy parameters
    _solver_params.push_back(makeLinearSolverParams());
  }
 
  _nonlocal_cm.resize(numSolverSystems());
  _cm.resize(numSolverSystems());
 
  _time = 0.0;
  _time_old = 0.0;
  _time_older = 0.0;
  _t_step = 0;
  _dt = 0;
  _dt_old = _dt;
 
  unsigned int n_threads = numThreads();
 
  _real_zero.resize(n_threads, 0.);
  _scalar_zero.resize(n_threads);
  _zero.resize(n_threads);
  _phi_zero.resize(n_threads);
  _ad_zero.resize(n_threads);
  _grad_zero.resize(n_threads);
  _ad_grad_zero.resize(n_threads);
  _grad_phi_zero.resize(n_threads);
  _second_zero.resize(n_threads);
  _ad_second_zero.resize(n_threads);
  _second_phi_zero.resize(n_threads);
  _point_zero.resize(n_threads);
  _vector_zero.resize(n_threads);
  _vector_curl_zero.resize(n_threads);
  _uo_jacobian_moose_vars.resize(n_threads);
 
  _has_active_material_properties.resize(n_threads, 0);
 
  _block_mat_side_cache.resize(n_threads);
  _bnd_mat_side_cache.resize(n_threads);
  _interface_mat_side_cache.resize(n_threads);
 
  es().parameters.set<FEProblemBase *>("_fe_problem_base") = this;
 
  if (isParamValid("restart_file_base"))
  {
    std::string restart_file_base = getParam<FileNameNoExtension>("restart_file_base");
 
    // This check reverts to old behavior of providing "restart_file_base=" to mean
    // don't restart... BISON currently relies on this. It could probably be removed.
    // The new MooseUtils::convertLatestCheckpoint will error out if a checkpoint file
    // is not found, which I think makes sense. Which means, without this, if you
    // set "restart_file_base=", you'll get a "No checkpoint file found" error
    if (restart_file_base.size())
    {
      restart_file_base = MooseUtils::convertLatestCheckpoint(restart_file_base);
      setRestartFile(restart_file_base);
    }
  }
 
  // // Generally speaking, the mesh is prepared for use, and consequently remote elements are deleted
  // // well before our Problem(s) are constructed. Historically, in MooseMesh we have a bunch of
  // // needs_prepare type flags that make it so we never call prepare_for_use (and consequently
  // // delete_remote_elements) again. So the below line, historically, has had no impact. HOWEVER:
  // // I've added some code in SetupMeshCompleteAction for deleting remote elements post
  // // EquationSystems::init. If I execute that code without default ghosting, then I get > 40 MOOSE
  // // test failures, so we clearly have some simulations that are not yet covered properly by
  // // relationship managers. Until that is resolved, I am going to retain default geometric ghosting
  // if (!_default_ghosting)
  //   _mesh.getMesh().remove_ghosting_functor(_mesh.getMesh().default_ghosting());
 
#if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
  // Main app should hold the default database to handle system petsc options
  if (!_app.isUltimateMaster())
    LibmeshPetscCall(PetscOptionsCreate(&_petsc_option_data_base));
#endif
 
  if (!_solve)
  {
    // If we are not solving, we do not care about seeing unused petsc options
    Moose::PetscSupport::setSinglePetscOption("-options_left", "0");
    // We don't want petscSetOptions being called in solve and clearing the option that was just set
    _is_petsc_options_inserted = true;
  }
}

◆ ~FEProblemBase()

FEProblemBase::~FEProblemBase ( )

virtual

Definition at line 878 of file FEProblemBase.C.

{
  // Flush the Console stream, the underlying call to Console::mooseConsole
  // relies on a call to Output::checkInterval that has references to
  // _time, etc. If it is not flushed here memory problems arise if you have
  // an unflushed stream and start destructing things.
  _console << std::flush;
 
  unsigned int n_threads = numThreads();
  for (unsigned int i = 0; i < n_threads; i++)
  {
    _zero[i].release();
    _phi_zero[i].release();
    _scalar_zero[i].release();
    _grad_zero[i].release();
    _grad_phi_zero[i].release();
    _second_zero[i].release();
    _second_phi_zero[i].release();
    _vector_zero[i].release();
    _vector_curl_zero[i].release();
    _ad_zero[i].release();
    _ad_grad_zero[i].release();
    _ad_second_zero[i].release();
  }
 
#if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
  if (!_app.isUltimateMaster())
  {
    auto ierr = PetscOptionsDestroy(&_petsc_option_data_base);
    // Don't throw on destruction
    CHKERRABORT(this->comm().get(), ierr);
  }
#endif
}

Member Function Documentation

◆ _setCLIOption()

void Problem::_setCLIOption ( )

inlineinherited

For Internal Use.

Definition at line 32 of file Problem.h.

32{ _cli_option_found = true; }

Problem::_cli_option_found

bool _cli_option_found

True if the CLI option is found.

Definition Problem.h:52

◆ acceptInvalidSolution()

bool FEProblemBase::acceptInvalidSolution ( ) const

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

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

Definition at line 4143 of file FEProblemBase.C.

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

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

◆ adaptivity()

Adaptivity & FEProblemBase::adaptivity ( )

inline

Definition at line 2178 of file FEProblemBase.h.

2178{ return _adaptivity; }

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

◆ adaptMesh()

bool FEProblemBase::adaptMesh ( )

virtual

Returns: Whether or not the mesh was changed

Reimplemented in DumpObjectsProblem.

Definition at line 8923 of file FEProblemBase.C.

{
  // reset cycle counter
  _cycles_completed = 0;
 
  if (!_adaptivity.isAdaptivityDue())
    return false;
 
  TIME_SECTION("adaptMesh", 3, "Adapting Mesh");
 
  unsigned int cycles_per_step = _adaptivity.getCyclesPerStep();
 
  bool mesh_changed = false;
 
  for (unsigned int i = 0; i < cycles_per_step; ++i)
  {
    if (!_mesh.interiorLowerDBlocks().empty() || !_mesh.boundaryLowerDBlocks().empty())
      mooseError("HFEM does not support mesh adaptivity currently.");
 
    // Markers were already computed once by Executioner
    if (_adaptivity.getRecomputeMarkersFlag() && i > 0)
      computeMarkers();
 
    bool mesh_changed_this_step;
    mesh_changed_this_step = _adaptivity.adaptMesh();
 
    if (mesh_changed_this_step)
    {
      mesh_changed = true;
 
      meshChanged(
          /*intermediate_change=*/true, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
      _cycles_completed++;
    }
    else
    {
      // If the mesh didn't change, we still need to update the displaced mesh
      // to undo the undisplacement performed in Adaptivity::adaptMesh
      if (_displaced_problem)
        _displaced_problem->updateMesh();
 
      _console << "Mesh unchanged, skipping remaining steps..." << std::endl;
      break;
    }
 
    // Show adaptivity progress
    _console << std::flush;
  }
 
  // We're done with all intermediate changes; now get systems ready
  // for real if necessary.
  if (mesh_changed)
    es().reinit_systems();
 
  // Execute multi-apps that need to run after adaptivity, but before the next timestep.
  execMultiApps(EXEC_POST_ADAPTIVITY);
 
  return mesh_changed;
}

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

◆ addAlgebraicGhostingFunctor()

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

inherited

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

Definition at line 1031 of file SubProblem.C.

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

◆ addAnyRedistributers()

void FEProblemBase::addAnyRedistributers ( )

private

Definition at line 6779 of file FEProblemBase.C.

{
#ifdef LIBMESH_ENABLE_AMR
  if ((_adaptivity.isOn() || _num_grid_steps) &&
      (_material_props.hasStatefulProperties() || _bnd_material_props.hasStatefulProperties() ||
       _neighbor_material_props.hasStatefulProperties()))
  {
    // Even on a serialized Mesh, we don't keep our material
    // properties serialized, so we'll rely on the callback to
    // redistribute() to redistribute properties at the same time
    // libMesh is redistributing elements.
    auto add_redistributer = [this](MooseMesh & mesh,
                                    const std::string & redistributer_name,
                                    const bool use_displaced_mesh)
    {
      InputParameters redistribute_params = RedistributeProperties::validParams();
      redistribute_params.set<MooseApp *>(MooseBase::app_param) = &_app;
      redistribute_params.set<std::string>("for_whom") = this->name();
      redistribute_params.set<MooseMesh *>("mesh") = &mesh;
      redistribute_params.set<Moose::RelationshipManagerType>("rm_type") =
          Moose::RelationshipManagerType::GEOMETRIC;
      redistribute_params.set<bool>("use_displaced_mesh") = use_displaced_mesh;
      redistribute_params.setHitNode(*parameters().getHitNode(), {});
 
      std::shared_ptr<RedistributeProperties> redistributer =
          _factory.create<RedistributeProperties>(
              "RedistributeProperties", redistributer_name, redistribute_params);
 
      if (_material_props.hasStatefulProperties())
        redistributer->addMaterialPropertyStorage(_material_props);
 
      if (_bnd_material_props.hasStatefulProperties())
        redistributer->addMaterialPropertyStorage(_bnd_material_props);
 
      if (_neighbor_material_props.hasStatefulProperties())
        redistributer->addMaterialPropertyStorage(_neighbor_material_props);
 
      mesh.getMesh().add_ghosting_functor(redistributer);
    };
 
    add_redistributer(_mesh, "mesh_property_redistributer", false);
    if (_displaced_problem)
      add_redistributer(_displaced_problem->mesh(), "displaced_mesh_property_redistributer", true);
  }
#endif // LIBMESH_ENABLE_AMR
}

◆ addAuxArrayVariable()

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

virtual

Definition at line 3471 of file FEProblemBase.C.

{
  parallel_object_only();
 
  mooseDeprecated("Please use the addAuxVariable(var_type, var_name, params) API instead");
 
  if (duplicateVariableCheck(var_name, type, /* is_aux = */ true, active_subdomains))
    return;
 
  InputParameters params = _factory.getValidParams("ArrayMooseVariable");
  params.set<FEProblemBase *>("_fe_problem_base") = this;
  params.set<Moose::VarKindType>("_var_kind") = Moose::VarKindType::VAR_AUXILIARY;
  params.set<MooseEnum>("order") = type.order.get_order();
  params.set<MooseEnum>("family") = Moose::stringify(type.family);
  params.set<bool>("p_refinement") = type.p_refinement;
  params.set<unsigned int>("components") = components;
 
  if (active_subdomains)
    for (const SubdomainID & id : *active_subdomains)
      params.set<std::vector<SubdomainName>>("block").push_back(Moose::stringify(id));
 
  logAdd("Variable", var_name, "ArrayMooseVariable", params);
  _aux->addVariable("ArrayMooseVariable", var_name, params);
  if (_displaced_problem)
    _displaced_problem->addAuxVariable("ArrayMooseVariable", var_name, params);
}

◆ addAuxKernel()

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

virtual

Reimplemented in MFEMProblem.

Definition at line 3536 of file FEProblemBase.C.

{
  parallel_object_only();
 
  setAuxKernelParamsAndLog(kernel_name, name, parameters, "AuxKernel");
 
  _aux->addKernel(kernel_name, name, parameters);
}

◆ addAuxScalarKernel()

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

virtual

Definition at line 3548 of file FEProblemBase.C.

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

◆ addAuxScalarVariable()

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

virtual

Definition at line 3502 of file FEProblemBase.C.

{
  parallel_object_only();
 
  mooseDeprecated("Please use the addAuxVariable(var_type, var_name, params) API instead");
 
  if (order > _max_scalar_order)
    _max_scalar_order = order;
 
  FEType type(order, SCALAR);
  if (duplicateVariableCheck(var_name, type, /* is_aux = */ true, active_subdomains))
    return;
 
  InputParameters params = _factory.getValidParams("MooseVariableScalar");
  params.set<FEProblemBase *>("_fe_problem_base") = this;
  params.set<Moose::VarKindType>("_var_kind") = Moose::VarKindType::VAR_AUXILIARY;
 
  params.set<MooseEnum>("order") = type.order.get_order();
  params.set<MooseEnum>("family") = "SCALAR";
  params.set<std::vector<Real>>("scaling") = std::vector<Real>{1};
  if (active_subdomains)
    for (const SubdomainID & id : *active_subdomains)
      params.set<std::vector<SubdomainName>>("block").push_back(Moose::stringify(id));
 
  logAdd("ScalarVariable", var_name, "MooseVariableScalar", params);
  _aux->addVariable("MooseVariableScalar", var_name, params);
  if (_displaced_problem)
    _displaced_problem->addAuxVariable("MooseVariableScalar", var_name, params);
}

◆ addAuxVariable() [1/2]

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

virtual

Reimplemented in DumpObjectsProblem.

◆ addAuxVariable() [2/2]

void FEProblemBase::addAuxVariable	(	const std::string &	var_type,
		const std::string &	var_name,
		InputParameters &	params
	)

virtual

Canonical method for adding an auxiliary variable.

Parameters

var_type	the type of the variable, e.g. MooseVariableScalar
var_name	the variable name, e.g. 'u'
params	the InputParameters from which to construct the variable

Reimplemented in MFEMProblem, and DumpObjectsProblem.

Definition at line 3397 of file FEProblemBase.C.

{
  parallel_object_only();
 
  const auto fe_type = MooseUtils::variableFEType(params);
 
  const auto active_subdomains_vector =
      _mesh.getSubdomainIDs(params.get<std::vector<SubdomainName>>("block"));
  const std::set<SubdomainID> active_subdomains(active_subdomains_vector.begin(),
                                                active_subdomains_vector.end());
 
  if (duplicateVariableCheck(var_name, fe_type, /* is_aux = */ true, &active_subdomains))
    return;
 
  params.set<FEProblemBase *>("_fe_problem_base") = this;
  params.set<Moose::VarKindType>("_var_kind") = Moose::VarKindType::VAR_AUXILIARY;
 
  logAdd("AuxVariable", var_name, var_type, params);
  _aux->addVariable(var_type, var_name, params);
  if (_displaced_problem)
    // MooseObjects need to be unique so change the name here
    _displaced_problem->addAuxVariable(var_type, var_name, params);
}

Referenced by addElementalFieldVariable(), and AddAuxVariableAction::init().

◆ addBoundaryCondition()

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

virtual

Reimplemented in MFEMProblem.

Definition at line 3326 of file FEProblemBase.C.

{
  parallel_object_only();
 
  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError(
        "You are trying to add a BoundaryCondition to a linear variable/system, which is not "
        "supported at the moment!");
 
  setResidualObjectParamsAndLog(
      bc_name, name, parameters, nl_sys_num, "BoundaryCondition", _reinit_displaced_face);
  _nl[nl_sys_num]->addBoundaryCondition(bc_name, name, parameters);
}

Referenced by DiffusionCG::addBoundaryConditionsFromComponents(), and DiffusionCG::addFEBCs().

◆ addCachedJacobian()

void FEProblemBase::addCachedJacobian ( const THREAD_ID tid )

overridevirtual

Reimplemented from SubProblem.

Definition at line 2239 of file FEProblemBase.C.

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

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

◆ addCachedResidual()

void FEProblemBase::addCachedResidual ( const THREAD_ID tid )

overridevirtual

Reimplemented from SubProblem.

Definition at line 2110 of file FEProblemBase.C.

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

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

◆ addCachedResidualDirectly()

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

virtual

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

{
  if (_current_nl_sys->hasVector(_current_nl_sys->timeVectorTag()))
    _assembly[tid][_current_nl_sys->number()]->addCachedResidualDirectly(
        residual, Assembly::GlobalDataKey{}, getVectorTag(_current_nl_sys->timeVectorTag()));
 
  if (_current_nl_sys->hasVector(_current_nl_sys->nonTimeVectorTag()))
    _assembly[tid][_current_nl_sys->number()]->addCachedResidualDirectly(
        residual, Assembly::GlobalDataKey{}, getVectorTag(_current_nl_sys->nonTimeVectorTag()));
 
  std::vector<VectorTag> extra_residual_vector_tags;
  extra_residual_vector_tags.reserve(currentResidualVectorTags().size());
  const auto time_tag = _current_nl_sys->timeVectorTag();
  const auto non_time_tag = _current_nl_sys->nonTimeVectorTag();
  for (const auto & vector_tag : currentResidualVectorTags())
    if (vector_tag._id != time_tag && vector_tag._id != non_time_tag)
      extra_residual_vector_tags.push_back(vector_tag);
 
  // Flush extra vector tag caches (e.g. from extra_vector_tags on NodalConstraints)
  // to their respective system vectors after the standard TIME/NONTIME caches above.
  // Without this, NodalConstraint contributions to extra vector tags are silently
  // discarded by the blanket clearCachedResiduals.
  _assembly[tid][_current_nl_sys->number()]->addCachedResiduals(Assembly::GlobalDataKey{},
                                                                extra_residual_vector_tags);
 
  // We do this because by adding the cached residual directly, we cannot ensure that all of the
  // cached residuals are emptied after only the two add calls above
  _assembly[tid][_current_nl_sys->number()]->clearCachedResiduals(Assembly::GlobalDataKey{});
 
  if (_displaced_problem)
    _displaced_problem->addCachedResidualDirectly(residual, tid);
}

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

◆ addConstraint()

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

virtual

Definition at line 3344 of file FEProblemBase.C.

{
  parallel_object_only();
 
  _has_constraints = true;
 
  auto determine_var_param_name = [&parameters, this]()
  {
    if (parameters.isParamValid("variable"))
      return "variable";
    else
    {
      // must be a mortar constraint
      const bool has_secondary_var = parameters.isParamValid("secondary_variable");
      const bool has_primary_var = parameters.isParamValid("primary_variable");
      if (!has_secondary_var && !has_primary_var)
        mooseError(
            "Either a 'secondary_variable' or 'primary_variable' parameter must be supplied for '",
            parameters.getObjectName(),
            "'");
      return has_secondary_var ? "secondary_variable" : "primary_variable";
    }
  };
 
  const auto nl_sys_num =
      determineSolverSystem(parameters.varName(determine_var_param_name(), name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a Constraint to a linear variable/system, which is not "
               "supported at the moment!");
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
    _reinit_displaced_face = true;
  }
  else
  {
    // It might _want_ to use a displaced mesh... but we're not so set it to false
    if (parameters.have_parameter<bool>("use_displaced_mesh"))
      parameters.set<bool>("use_displaced_mesh") = false;
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }
 
  logAdd("Constraint", name, c_name, parameters);
  _nl[nl_sys_num]->addConstraint(c_name, name, parameters);
}

◆ addConsumedPropertyName()

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

inherited

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

Definition at line 728 of file SubProblem.C.

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

Referenced by MaterialPropertyInterface::addConsumedPropertyName().

◆ addConvergence()

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

virtual

Adds a Convergence object.

Definition at line 2742 of file FEProblemBase.C.

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

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

◆ addCouplingGhostingFunctor()

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

inherited

Add a coupling functor to this problem's DofMaps.

Definition at line 1064 of file SubProblem.C.

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

◆ addDamper()

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

virtual

Definition at line 5809 of file FEProblemBase.C.

{
  parallel_object_only();
 
  const auto nl_sys_num =
      parameters.isParamValid("variable")
          ? determineSolverSystem(parameters.varName("variable", name), true).second
          : (unsigned int)0;
 
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a DGKernel to a linear variable/system, which is not "
               "supported at the moment!");
 
  parameters.set<SubProblem *>("_subproblem") = this;
  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
 
  _has_dampers = true;
  logAdd("Damper", name, damper_name, parameters);
  _nl[nl_sys_num]->addDamper(damper_name, name, parameters);
}

◆ addDefaultMultiAppFixedPointConvergence()

void FEProblemBase::addDefaultMultiAppFixedPointConvergence ( const InputParameters & params )

Adds the default fixed point Convergence associated with the problem.

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

Parameters

[in] params Parameters to apply to Convergence parameters

Definition at line 2768 of file FEProblemBase.C.

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

◆ addDefaultNonlinearConvergence()

void FEProblemBase::addDefaultNonlinearConvergence ( const InputParameters & params )

virtual

Adds the default nonlinear Convergence associated with the problem.

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

Parameters

[in] params Parameters to apply to Convergence parameters

Reimplemented in ReferenceResidualProblem.

Definition at line 2756 of file FEProblemBase.C.

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

◆ addDefaultSteadyStateConvergence()

void FEProblemBase::addDefaultSteadyStateConvergence ( const InputParameters & params )

Adds the default steady-state detection Convergence.

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

Parameters

[in] params Parameters to apply to Convergence parameters

Definition at line 2779 of file FEProblemBase.C.

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

◆ addDGKernel()

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

virtual

Definition at line 3620 of file FEProblemBase.C.

{
  parallel_object_only();
 
  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a DGKernel to a linear variable/system, which is not "
               "supported at the moment!");
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
    _reinit_displaced_neighbor = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow DGKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this DGKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }
 
  logAdd("DGKernel", name, dg_kernel_name, parameters);
  _nl[nl_sys_num]->addDGKernel(dg_kernel_name, name, parameters);
 
  _has_internal_edge_residual_objects = true;
}

◆ addDiracKernel()

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

virtual

Definition at line 3580 of file FEProblemBase.C.

{
  parallel_object_only();
 
  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a DiracKernel to a linear variable/system, which is not "
               "supported at the moment!");
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
    _reinit_displaced_elem = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow DiracKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this DiracKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }
 
  logAdd("DiracKernel", name, kernel_name, parameters);
  _nl[nl_sys_num]->addDiracKernel(kernel_name, name, parameters);
}

◆ addDisplacedProblem()

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

virtual

Definition at line 8722 of file FEProblemBase.C.

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

◆ addDistribution()

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

virtual

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

Definition at line 2915 of file FEProblemBase.C.

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

◆ addElementalFieldVariable()

void FEProblemBase::addElementalFieldVariable	(	const std::string &	var_type,
		const std::string &	var_name,
		InputParameters &	params
	)

virtual

Add an elemental field variable for use in the adaptivity system.

Reimplemented in MFEMProblem.

Definition at line 3424 of file FEProblemBase.C.

{
  addAuxVariable(var_type, var_name, params);
}

Referenced by AddElementalFieldAction::init().

◆ addFunction()

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

virtual

Reimplemented in MFEMProblem.

Definition at line 2716 of file FEProblemBase.C.

{
  parallel_object_only();
 
  parameters.set<SubProblem *>("_subproblem") = this;
 
  for (THREAD_ID tid = 0; tid < numThreads(); tid++)
  {
    std::shared_ptr<Function> func = _factory.create<Function>(type, name, parameters, tid);
    logAdd("Function", name, type, parameters);
    _functions.addObject(func, tid);
 
    if (auto * const functor = dynamic_cast<Moose::FunctorBase<Real> *>(func.get()))
    {
      this->addFunctor(name, *functor, tid);
      if (_displaced_problem)
        _displaced_problem->addFunctor(name, *functor, tid);
    }
    else
      mooseError("Unrecognized function functor type");
  }
}

Referenced by getFunction().

◆ addFunctor()

template<typename T >

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

inherited

add a functor to the problem functor container

Definition at line 1371 of file SubProblem.h.

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

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

◆ addFunctorMaterial()

void FEProblemBase::addFunctorMaterial	(	const std::string &	functor_material_name,
		const std::string &	name,
		InputParameters &	parameters
	)

virtual

Reimplemented in MFEMProblem.

Definition at line 4150 of file FEProblemBase.C.

{
  parallel_object_only();
 
  auto add_functor_materials = [&](const auto & parameters, const auto & name)
  {
    for (THREAD_ID tid = 0; tid < numThreads(); tid++)
    {
      // Create the general Block/Boundary MaterialBase object
      std::shared_ptr<MaterialBase> material =
          _factory.create<MaterialBase>(functor_material_name, name, parameters, tid);
      logAdd("FunctorMaterial", name, functor_material_name, parameters);
      _all_materials.addObject(material, tid);
      _materials.addObject(material, tid);
    }
  };
 
  parameters.set<SubProblem *>("_subproblem") = this;
  add_functor_materials(parameters, name);
  if (_displaced_problem)
  {
    auto disp_params = parameters;
    disp_params.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    add_functor_materials(disp_params, name + "_displaced");
  }
}

◆ addFVBC()

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

virtual

Definition at line 3674 of file FEProblemBase.C.

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

Referenced by DiffusionFV::addFVBCs().

◆ addFVGradientMethod()

void FEProblemBase::addFVGradientMethod	(	const std::string &	method_type,
		const std::string &	name,
		InputParameters &	parameters
	)

virtual

Add an FV gradient method.

Parameters

method_type	The type of the method.
name	The name of the method.
parameters	The input parameters of the method.

Definition at line 4794 of file FEProblemBase.C.

{
  parallel_object_only();
 
  addObjectParamsHelper(parameters, name);
 
  for (const auto tid : make_range(libMesh::n_threads()))
  {
    auto method = _factory.create<FVGradientMethod>(method_type, name, parameters, tid);
    logAdd("FVGradientMethod", name, method_type, parameters);
    theWarehouse().add(method);
  }
}

◆ addFVInitialCondition()

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

virtual

Add an initial condition for a finite volume variables.

Parameters

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

Definition at line 3843 of file FEProblemBase.C.

{
  parallel_object_only();
 
  // before we start to mess with the initial condition, we need to check parameters for errors.
  parameters.checkParams(name);
  const std::string & var_name = parameters.get<VariableName>("variable");
 
  // Forbid initial conditions on a restarted problem, as they would override the restart
  checkICRestartError(ic_name, name, var_name);
 
  parameters.set<SubProblem *>("_subproblem") = this;
 
  // field IC
  if (hasVariable(var_name))
  {
    for (THREAD_ID tid = 0; tid < numThreads(); ++tid)
    {
      auto & var = getVariable(
          tid, var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY);
      parameters.set<SystemBase *>("_sys") = &var.sys();
      std::shared_ptr<FVInitialConditionBase> ic;
      if (var.isFV())
        ic = _factory.create<FVInitialCondition>(ic_name, name, parameters, tid);
      else
        mooseError(
            "Your variable for an FVInitialCondition needs to be an a finite volume variable!");
      _fv_ics.addObject(ic, tid);
    }
  }
  else
    mooseError("Variable '",
               var_name,
               "' requested in finite volume initial condition '",
               name,
               "' does not exist.");
}

◆ addFVInterfaceKernel()

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

virtual

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

Definition at line 3682 of file FEProblemBase.C.

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

◆ addFVInterpolationMethod()

void FEProblemBase::addFVInterpolationMethod	(	const std::string &	method_type,
		const std::string &	name,
		InputParameters &	parameters
	)

virtual

Add an FV interpolation method.

Parameters

method_type	The type of the method.
name	The name of the method.
parameters	The input parameters of the method.

Definition at line 4777 of file FEProblemBase.C.

{
  parallel_object_only();
 
  addObjectParamsHelper(parameters, name);
 
  for (const auto tid : make_range(numThreads()))
  {
    auto method = _factory.create<FVInterpolationMethod>(method_type, name, parameters, tid);
    logAdd("FVInterpolationMethod", name, method_type, parameters);
    theWarehouse().add(method);
  }
}

◆ addFVKernel()

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

virtual

Definition at line 3660 of file FEProblemBase.C.

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

Referenced by DiffusionFV::addFVKernels().

◆ addGhostedBoundary()

void FEProblemBase::addGhostedBoundary ( BoundaryID boundary_id )

overridevirtual

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

Implements SubProblem.

Definition at line 2335 of file FEProblemBase.C.

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

Referenced by DisplacedProblem::addGhostedBoundary().

◆ addGhostedElem()

void FEProblemBase::addGhostedElem ( dof_id_type elem_id )

overridevirtual

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

Implements SubProblem.

Definition at line 2328 of file FEProblemBase.C.

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

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

◆ addHDGKernel()

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

virtual

Definition at line 3240 of file FEProblemBase.C.

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

◆ addIndicator()

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

virtual

Reimplemented in MFEMProblem.

Definition at line 5840 of file FEProblemBase.C.

{
  parallel_object_only();
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
    _reinit_displaced_elem = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow Indicators to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this Indicator.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _aux.get();
  }
 
  for (THREAD_ID tid = 0; tid < numThreads(); tid++)
  {
    std::shared_ptr<Indicator> indicator =
        _factory.create<Indicator>(indicator_name, name, parameters, tid);
    logAdd("Indicator", name, indicator_name, parameters);
    std::shared_ptr<InternalSideIndicatorBase> isi =
        std::dynamic_pointer_cast<InternalSideIndicatorBase>(indicator);
    if (isi)
      _internal_side_indicators.addObject(isi, tid);
    else
      _indicators.addObject(indicator, tid);
  }
}

◆ addInitialCondition()

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

virtual

Reimplemented in MFEMProblem.

Definition at line 3783 of file FEProblemBase.C.

{
  parallel_object_only();
 
  // before we start to mess with the initial condition, we need to check parameters for errors.
  parameters.checkParams(name);
  const std::string & var_name = parameters.get<VariableName>("variable");
 
  // Forbid initial conditions on a restarted problem, as they would override the restart
  checkICRestartError(ic_name, name, var_name);
 
  parameters.set<SubProblem *>("_subproblem") = this;
 
  // field IC
  if (hasVariable(var_name))
  {
    for (THREAD_ID tid = 0; tid < numThreads(); ++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 if (dynamic_cast<ArrayMooseVariable *>(&var))
        ic = _factory.create<ArrayInitialCondition>(ic_name, name, parameters, tid);
      else if (dynamic_cast<MooseVariableFVReal *>(&var))
        ic = _factory.create<InitialCondition>(ic_name, name, parameters, tid);
      else if (dynamic_cast<MooseLinearVariableFVReal *>(&var))
        ic = _factory.create<InitialCondition>(ic_name, name, parameters, tid);
      else
        mooseError("Your FE variable in initial condition ",
                   name,
                   " must be either of scalar or vector type");
      logAdd("IC", name, ic_name, parameters);
      _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);
    logAdd("ScalarIC", name, ic_name, parameters);
    _scalar_ics.addObject(ic);
  }
 
  else
    mooseError(
        "Variable '", var_name, "' requested in initial condition '", name, "' does not exist.");
}

Referenced by DiffusionPhysicsBase::addInitialConditions(), and DiffusionPhysicsBase::addInitialConditionsFromComponents().

◆ addInterfaceKernel()

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

virtual

Definition at line 3711 of file FEProblemBase.C.

{
  parallel_object_only();
 
  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a InterfaceKernel to a linear variable/system, which is not "
               "supported at the moment!");
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
    _reinit_displaced_neighbor = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow InterfaceKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this InterfaceKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }
 
  logAdd("InterfaceKernel", name, interface_kernel_name, parameters);
  _nl[nl_sys_num]->addInterfaceKernel(interface_kernel_name, name, parameters);
 
  _has_internal_edge_residual_objects = true;
}

◆ addInterfaceMaterial()

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

virtual

Definition at line 4188 of file FEProblemBase.C.

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

◆ addJacobian()

void FEProblemBase::addJacobian ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 2172 of file FEProblemBase.C.

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

Referenced by ComputeDiracThread::postElement().

◆ addJacobianBlockTags()

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

virtual

Definition at line 2247 of file FEProblemBase.C.

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

Referenced by ComputeJacobianBlocksThread::postElement().

◆ addJacobianLowerD()

void FEProblemBase::addJacobianLowerD ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 2202 of file FEProblemBase.C.

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

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

◆ addJacobianNeighbor() [1/3]

void FEProblemBase::addJacobianNeighbor ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 2186 of file FEProblemBase.C.

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

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

◆ addJacobianNeighbor() [2/3]

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

overridevirtual

◆ addJacobianNeighbor() [3/3]

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

pure virtualinherited

◆ addJacobianNeighborLowerD()

void FEProblemBase::addJacobianNeighborLowerD ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 2194 of file FEProblemBase.C.

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

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

◆ addJacobianOffDiagScalar()

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

virtual

Definition at line 2216 of file FEProblemBase.C.

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

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians().

◆ addJacobianScalar()

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

virtual

Definition at line 2210 of file FEProblemBase.C.

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

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians().

◆ addKernel()

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

virtual

Reimplemented in MFEMProblem.

Definition at line 3224 of file FEProblemBase.C.

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

Referenced by DiffusionCG::addFEKernels().

◆ addKokkosAuxKernel()

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

virtual

◆ addKokkosBoundaryCondition()

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

virtual

◆ addKokkosFunction()

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

virtual

Add a Kokkos function to the problem.

Parameters

type	The Kokkos function type
name	The Kokkos function name
parameters	The Kokkos function input parameters

Referenced by getKokkosFunction().

◆ addKokkosKernel()

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

virtual

◆ addKokkosLinearFVBC()

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

virtual

◆ addKokkosLinearFVKernel()

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

virtual

◆ addKokkosMaterial()

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

virtual

◆ addKokkosMeshInitializationHook()

void FEProblemBase::addKokkosMeshInitializationHook ( std::function< void()> function )

inline

Add a function hook that needs to be called after Kokkos mesh initialization.

Parameters

function The function to be called

Definition at line 3087 of file FEProblemBase.h.

  {
    _kokkos_mesh_initialization_hooks.push_back(function);
  }

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

◆ addKokkosNodalKernel()

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

virtual

◆ addKokkosPostprocessor()

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

virtual

◆ addKokkosReporter()

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

virtual

◆ addKokkosUserObject()

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

virtual

◆ addKokkosVectorPostprocessor()

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

virtual

◆ addLinearFVBC()

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

virtual

Definition at line 3701 of file FEProblemBase.C.

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

◆ addLinearFVKernel()

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

virtual

Definition at line 3693 of file FEProblemBase.C.

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

◆ addLineSearch()

virtual void FEProblemBase::addLineSearch ( const InputParameters & )

inlinevirtual

add a MOOSE line search

Reimplemented in DumpObjectsProblem, and FEProblem.

Definition at line 838 of file FEProblemBase.h.

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

Referenced by FEProblemSolve::FEProblemSolve().

◆ addMarker()

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

virtual

Reimplemented in MFEMProblem.

Definition at line 5883 of file FEProblemBase.C.

{
  parallel_object_only();
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
    _reinit_displaced_elem = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow Markers to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this Marker.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _aux.get();
  }
 
  for (THREAD_ID tid = 0; tid < numThreads(); tid++)
  {
    std::shared_ptr<Marker> marker = _factory.create<Marker>(marker_name, name, parameters, tid);
    logAdd("Marker", name, marker_name, parameters);
    _markers.addObject(marker, tid);
  }
}

◆ addMaterial()

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

virtual

Reimplemented in MFEMProblem.

Definition at line 4180 of file FEProblemBase.C.

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

Referenced by ComponentMaterialPropertyInterface::addMaterials().

◆ addMaterialHelper()

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

virtual

Definition at line 4196 of file FEProblemBase.C.

{
  parallel_object_only();
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    _reinit_displaced_elem = _reinit_displaced_face = _reinit_displaced_neighbor = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow Materials to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this Material.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
  }
 
  unsigned int n_threads = numThreads();
 
#ifdef MOOSE_KOKKOS_ENABLED
  if (parameters.isKokkosObject())
    n_threads = 1;
#endif
 
  for (THREAD_ID tid = 0; tid < n_threads; tid++)
  {
    // Create the general Block/Boundary MaterialBase object
    std::shared_ptr<MaterialBase> material =
        _factory.create<MaterialBase>(mat_name, name, parameters, tid);
    logAdd("Material", name, mat_name, parameters);
    bool discrete = !material->getParam<bool>("compute");
 
    // If the object is boundary restricted or if it is a functor material we do not create the
    // neighbor and face objects
    if (material->boundaryRestricted() || dynamic_cast<FunctorMaterial *>(material.get()))
    {
      _all_materials.addObject(material, tid);
      if (discrete)
        _discrete_materials.addObject(material, tid);
      else
        for (auto && warehouse : warehouses)
          warehouse->addObject(material, tid);
    }
 
    // Non-boundary restricted require face and neighbor objects
    else
    {
      // TODO: we only need to do this if we have needs for face materials (e.g.
      // FV, DG, etc.) - but currently we always do it.  Figure out how to fix
      // this.
 
      // The name of the object being created, this is changed multiple times as objects are
      // created below
      std::string object_name;
 
      // Create a copy of the supplied parameters to the setting for "_material_data_type" isn't
      // used from a previous tid loop
      InputParameters current_parameters = parameters;
 
      // face material
      current_parameters.set<Moose::MaterialDataType>("_material_data_type") =
          Moose::FACE_MATERIAL_DATA;
      object_name = name + "_face";
      std::shared_ptr<MaterialBase> face_material =
          _factory.create<MaterialBase>(mat_name, object_name, current_parameters, tid);
 
      // neighbor material
      current_parameters.set<Moose::MaterialDataType>("_material_data_type") =
          Moose::NEIGHBOR_MATERIAL_DATA;
      current_parameters.set<bool>("_neighbor") = true;
      object_name = name + "_neighbor";
      std::shared_ptr<MaterialBase> neighbor_material =
          _factory.create<MaterialBase>(mat_name, object_name, current_parameters, tid);
 
      // Store the material objects
      _all_materials.addObjects(material, neighbor_material, face_material, tid);
 
      if (discrete)
        _discrete_materials.addObjects(material, neighbor_material, face_material, tid);
      else
        for (auto && warehouse : warehouses)
          warehouse->addObjects(material, neighbor_material, face_material, tid);
 
      // Names of all controllable parameters for this Material object
      const std::string & base = parameters.getBase();
      MooseObjectParameterName name(MooseObjectName(base, material->name()), "*");
      const auto param_names =
          _app.getInputParameterWarehouse().getControllableParameterNames(name);
 
      // Connect parameters of the primary Material object to those on the face and neighbor
      // objects
      for (const auto & p_name : param_names)
      {
        MooseObjectParameterName primary_name(MooseObjectName(base, material->name()),
                                              p_name.parameter());
        MooseObjectParameterName face_name(MooseObjectName(base, face_material->name()),
                                           p_name.parameter());
        MooseObjectParameterName neighbor_name(MooseObjectName(base, neighbor_material->name()),
                                               p_name.parameter());
        _app.getInputParameterWarehouse().addControllableParameterConnection(
            primary_name, face_name, false);
        _app.getInputParameterWarehouse().addControllableParameterConnection(
            primary_name, neighbor_name, false);
      }
    }
  }
}

Referenced by addInterfaceMaterial(), and addMaterial().

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

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

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

◆ addMeshDivision()

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

virtual

Add a MeshDivision.

Definition at line 2870 of file FEProblemBase.C.

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

◆ addMultiApp()

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

virtual

Add a MultiApp to the problem.

Definition at line 5920 of file FEProblemBase.C.

{
  parallel_object_only();
 
  parameters.set<MPI_Comm>("_mpi_comm") = _communicator.get();
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
    _reinit_displaced_elem = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow MultiApps to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this MultiApp.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _aux.get();
  }
 
  std::shared_ptr<MultiApp> multi_app = _factory.create<MultiApp>(multi_app_name, name, parameters);
  logAdd("MultiApp", name, multi_app_name, parameters);
  multi_app->possiblyCreateChildApplications();
 
  _multi_apps.addObject(multi_app);
 
  // Store TransientMultiApp objects in another container, this is needed for calling computeDT
  std::shared_ptr<TransientMultiApp> trans_multi_app =
      std::dynamic_pointer_cast<TransientMultiApp>(multi_app);
  if (trans_multi_app)
    _transient_multi_apps.addObject(trans_multi_app);
}

◆ addNodalKernel()

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

virtual

Definition at line 3256 of file FEProblemBase.C.

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

◆ addNotZeroedVectorTag()

void SubProblem::addNotZeroedVectorTag ( const TagID tag )

inherited

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

Parameters

tag	the TagID of the vector that will be manually managed

Definition at line 141 of file SubProblem.C.

{
  _not_zeroed_tagged_vectors.insert(tag);
}

Referenced by createTagVectors().

◆ addObject()

template<typename T >

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

Method for creating and adding an object to the warehouse.

Template Parameters

T	The base object type (registered in the Factory)

Parameters

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

Returns: A vector of shared_ptrs to the added objects

Definition at line 3821 of file FEProblemBase.h.

{
  parallel_object_only();
 
  logAdd(MooseUtils::prettyCppType<T>(), name, type, parameters);
  // Add the _subproblem and _sys parameters depending on use_displaced_mesh
  addObjectParamsHelper(parameters, name, var_param_name);
 
  const auto n_threads = threaded ? this->numThreads() : 1;
  std::vector<std::shared_ptr<T>> objects(n_threads);
  for (THREAD_ID tid = 0; tid < n_threads; ++tid)
  {
    std::shared_ptr<T> obj = _factory.create<T>(type, name, parameters, tid);
    theWarehouse().add(obj);
    objects[tid] = std::move(obj);
  }
 
  return objects;
}

◆ addObjectParamsHelper()

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

protected

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

This is needed due to header includes/forward declaration issues

Definition at line 4597 of file FEProblemBase.C.

{
  // Due to objects like SolutionUserObject which manipulate libmesh objects
  // and variables directly at the back end, we need a default option here
  // which is going to be the pointer to the first solver system within this
  // problem
  unsigned int sys_num = 0;
  if (parameters.isParamValid(var_param_name))
  {
    const auto variable_name = parameters.varName(var_param_name, object_name);
    if (this->hasVariable(variable_name) || this->hasScalarVariable(variable_name))
      sys_num = getSystem(variable_name).number();
  }
  if (parameters.isParamValid("solver_sys"))
  {
    const auto var_sys_num = sys_num;
    sys_num = getSystemBase(parameters.get<SolverSystemName>("solver_sys")).number();
    if (sys_num != var_sys_num && parameters.isParamValid(var_param_name))
      mooseError("We dont support setting 'variable' to a variable that is not set to the same "
                 "system as the 'solver_sys' parameter");
  }
 
  if (_displaced_problem && parameters.have_parameter<bool>("use_displaced_mesh") &&
      parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    if (sys_num == _aux->number())
      parameters.set<SystemBase *>("_sys") = &_displaced_problem->systemBaseAuxiliary();
    else
      parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(sys_num);
  }
  else
  {
    // The object requested use_displaced_mesh, but it was overridden
    // due to there being no displacements variables in the [Mesh] block.
    // If that happened, update the value of use_displaced_mesh appropriately.
    if (!_displaced_problem && parameters.have_parameter<bool>("use_displaced_mesh") &&
        parameters.get<bool>("use_displaced_mesh"))
      parameters.set<bool>("use_displaced_mesh") = false;
 
    parameters.set<SubProblem *>("_subproblem") = this;
 
    if (sys_num == _aux->number())
      parameters.set<SystemBase *>("_sys") = _aux.get();
    else
      parameters.set<SystemBase *>("_sys") = _solver_systems[sys_num].get();
  }
}

Referenced by addFVGradientMethod(), addFVInterpolationMethod(), addObject(), and addUserObject().

◆ addOutput()

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

Adds an Output object.

Definition at line 9871 of file FEProblemBase.C.

{
  parallel_object_only();
 
  // Get a reference to the OutputWarehouse
  OutputWarehouse & output_warehouse = _app.getOutputWarehouse();
 
  // Reject the reserved names for objects not built by MOOSE
  if (!parameters.get<bool>("_built_by_moose") && output_warehouse.isReservedName(object_name))
    mooseError("The name '", object_name, "' is a reserved name for output objects");
 
  // Check that an object by the same name does not already exist; this must be done before the
  // object is created to avoid getting misleading errors from the Parser
  if (output_warehouse.hasOutput(object_name))
    mooseError("An output object named '", object_name, "' already exists");
 
  // Add a pointer to the FEProblemBase class
  parameters.addPrivateParam<FEProblemBase *>("_fe_problem_base", this);
 
  // --show-input should enable the display of the input file on the screen
  if (object_type == "Console" && _app.getParam<bool>("show_input") &&
      parameters.get<bool>("output_screen"))
    parameters.set<ExecFlagEnum>("execute_input_on") = EXEC_INITIAL;
 
  // Record whether this object's own block set 'file_base' itself before a common 'file_base'
  // from the [Outputs] block, if any, is copied down onto it below -- that copy makes
  // 'file_base' look valid and user-set on this object even when only the common block set it
  // (see #4215), so this must be captured first.
  if (parameters.isParamDefined("_file_base_set_by_own_block"))
    parameters.set<bool>("_file_base_set_by_own_block") = parameters.isParamSetByUser("file_base");
 
  // Apply only user-set parameters from the common [Outputs] block so that
  // each output type's own defaults are not overridden by common defaults.
  const InputParameters * common = output_warehouse.getCommonParameters();
  if (common)
    parameters.applyCommonUserSetParameters(*common);
 
  // Set the correct value for the binary flag for XDA/XDR output
  if (object_type == "XDR")
    parameters.set<bool>("_binary") = true;
  else if (object_type == "XDA")
    parameters.set<bool>("_binary") = false;
 
  // Adjust the checkpoint suffix if auto recovery was enabled
  if (object_name == "auto_recovery_checkpoint")
    parameters.set<std::string>("suffix") = "auto_recovery";
 
  // Create the object and add it to the warehouse
  std::shared_ptr<Output> output = _factory.create<Output>(object_type, object_name, parameters);
  logAdd("Output", object_name, object_type, parameters);
  output_warehouse.addOutput(output);
}

◆ addPiecewiseByBlockLambdaFunctor()

template<typename T , typename PolymorphicLambda >

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

inherited

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

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

Parameters

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

Returns: The added functor

Definition at line 1334 of file SubProblem.h.

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

Referenced by FunctorMaterial::addFunctorPropertyByBlocks().

◆ addPostprocessor()

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

virtual

Reimplemented in MFEMProblem.

Definition at line 4670 of file FEProblemBase.C.

{
  checkUserObjectNameCollision(name, "Postprocessor");
 
  addUserObject(pp_name, name, parameters);
}

Referenced by MFEMProblem::addPostprocessor(), and DiffusionPhysicsBase::addPostprocessors().

◆ addPredictor()

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

virtual

Definition at line 7713 of file FEProblemBase.C.

{
  parallel_object_only();
 
  if (!numNonlinearSystems() && numLinearSystems())
    mooseError("Vector bounds cannot be used with LinearSystems!");
 
  parameters.set<SubProblem *>("_subproblem") = this;
  std::shared_ptr<Predictor> predictor = _factory.create<Predictor>(type, name, parameters);
  logAdd("Predictor", name, type, parameters);
 
  for (auto & nl : _nl)
    nl->setPredictor(predictor);
}

Referenced by AB2PredictorCorrector::AB2PredictorCorrector().

◆ addReporter()

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

virtual

Add a Reporter object to the simulation.

Parameters

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

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

Definition at line 4690 of file FEProblemBase.C.

{
  checkUserObjectNameCollision(name, "Reporter");
 
  addUserObject(type, name, parameters);
}

Referenced by MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer().

◆ addResidual()

void FEProblemBase::addResidual ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 2057 of file FEProblemBase.C.

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

Referenced by ComputeDiracThread::postElement().

◆ addResidualLower()

void FEProblemBase::addResidualLower ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 2077 of file FEProblemBase.C.

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

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

◆ addResidualNeighbor()

void FEProblemBase::addResidualNeighbor ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 2067 of file FEProblemBase.C.

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

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

◆ addResidualScalar()

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

virtual

Definition at line 2087 of file FEProblemBase.C.

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

Referenced by NonlinearSystemBase::computeResidualInternal().

◆ addSampler()

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

virtual

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

Definition at line 2956 of file FEProblemBase.C.

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

◆ addScalarKernel()

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

virtual

Definition at line 3289 of file FEProblemBase.C.

{
  parallel_object_only();
 
  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a ScalarKernel to a linear variable/system, which is not "
               "supported at the moment!");
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow ScalarKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this ScalarKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }
 
  logAdd("ScalarKernel", name, kernel_name, parameters);
  _nl[nl_sys_num]->addScalarKernel(kernel_name, name, parameters);
}

◆ addTimeIntegrator()

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

virtual

Definition at line 7678 of file FEProblemBase.C.

{
  parallel_object_only();
 
  parameters.set<SubProblem *>("_subproblem") = this;
  logAdd("TimeIntegrator", name, type, parameters);
  _aux->addTimeIntegrator(type, name + ":aux", parameters);
  for (auto & sys : _solver_systems)
    sys->addTimeIntegrator(type, name + ":" + sys->name(), parameters);
  _has_time_integrator = true;
 
  // add vectors to store u_dot, u_dotdot, udot_old, u_dotdot_old and
  // solution vectors older than 2 time steps, if requested by the time
  // integrator
  _aux->addDotVectors();
  for (auto & nl : _nl)
  {
    nl->addDotVectors();
 
    auto tag_udot = nl->getTimeIntegrators()[0]->uDotFactorTag();
    if (!nl->hasVector(tag_udot))
      nl->associateVectorToTag(*nl->solutionUDot(), tag_udot);
    auto tag_udotdot = nl->getTimeIntegrators()[0]->uDotDotFactorTag();
    if (!nl->hasVector(tag_udotdot) && uDotDotRequested())
      nl->associateVectorToTag(*nl->solutionUDotDot(), tag_udotdot);
  }
 
  if (_displaced_problem)
    // Time integrator does not exist when displaced problem is created.
    _displaced_problem->addTimeIntegrator();
}

Referenced by TransientBase::setupTimeIntegrator().

◆ addTransfer()

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

virtual

Add a Transfer to the problem.

Reimplemented in MFEMProblem.

Definition at line 6465 of file FEProblemBase.C.

{
  parallel_object_only();
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
    _reinit_displaced_elem = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow 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. The get method is used to test for the
  // flag so the set by user flag is not reset, calling set with the true flag causes the set
  // by user status to be reset, which should only be done if the EXEC_SAME_AS_MULTIAPP is
  // being applied to the object.
  if (parameters.get<ExecFlagEnum>("execute_on").isValueSet(EXEC_SAME_AS_MULTIAPP))
  {
    ExecFlagEnum & exec_enum = parameters.set<ExecFlagEnum>("execute_on", true);
    std::shared_ptr<MultiApp> multiapp;
    if (parameters.isParamValid("multi_app"))
      multiapp = getMultiApp(parameters.get<MultiAppName>("multi_app"));
    // This catches the sibling transfer case, where we want to be executing only as often as the
    // receiving application. A transfer 'to' a multiapp is executed before that multiapp
    else if (parameters.isParamValid("to_multi_app"))
      multiapp = getMultiApp(parameters.get<MultiAppName>("to_multi_app"));
    else if (parameters.isParamValid("from_multi_app"))
      multiapp = getMultiApp(parameters.get<MultiAppName>("from_multi_app"));
    // else do nothing because the user has provided invalid input. They should get a nice error
    // about this during transfer construction. This necessitates checking for null in this next
    // line, however
    if (multiapp)
      exec_enum = multiapp->getParam<ExecFlagEnum>("execute_on");
  }
 
  // Create the Transfer objects
  std::shared_ptr<Transfer> transfer = _factory.create<Transfer>(transfer_name, name, parameters);
  logAdd("Transfer", name, transfer_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->directions().isValueSet(MultiAppTransfer::TO_MULTIAPP))
      _to_multi_app_transfers.addObject(multi_app_transfer);
    if (multi_app_transfer->directions().isValueSet(MultiAppTransfer::FROM_MULTIAPP))
      _from_multi_app_transfers.addObject(multi_app_transfer);
    if (multi_app_transfer->directions().isValueSet(MultiAppTransfer::BETWEEN_MULTIAPP))
      _between_multi_app_transfers.addObject(multi_app_transfer);
  }
  else
    _transfers.addObject(transfer);
}

Referenced by MFEMProblem::addTransfer().

◆ addUserObject()

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

virtual

Definition at line 4700 of file FEProblemBase.C.

{
  parallel_object_only();
 
  std::vector<std::shared_ptr<UserObject>> uos;
 
  // Add the _subproblem and _sys parameters depending on use_displaced_mesh
  addObjectParamsHelper(parameters, name);
 
  for (const auto tid : make_range(numThreads()))
  {
    // Create the UserObject
    std::shared_ptr<UserObject> user_object =
        _factory.create<UserObject>(user_object_name, name, parameters, tid);
    logAdd("UserObject", name, user_object_name, parameters);
    uos.push_back(user_object);
 
    if (tid != 0)
      user_object->setPrimaryThreadCopy(uos[0].get());
 
    theWarehouse().add(user_object);
 
    // Attempt to create all the possible UserObject types
    auto euo = std::dynamic_pointer_cast<ElementUserObject>(user_object);
    auto suo = std::dynamic_pointer_cast<SideUserObject>(user_object);
    auto isuo = std::dynamic_pointer_cast<InternalSideUserObject>(user_object);
    auto iuo = std::dynamic_pointer_cast<InterfaceUserObjectBase>(user_object);
    auto nuo = std::dynamic_pointer_cast<NodalUserObject>(user_object);
    auto duo = std::dynamic_pointer_cast<DomainUserObject>(user_object);
    auto guo = std::dynamic_pointer_cast<GeneralUserObject>(user_object);
    auto tguo = std::dynamic_pointer_cast<ThreadedGeneralUserObject>(user_object);
    auto muo = std::dynamic_pointer_cast<MortarUserObject>(user_object);
 
    // Account for displaced mesh use
    if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
    {
      // Whether to re-init or not depends on the attributes of the base classes.
      // For example, InterfaceUOBase has "_current_side_elem" and "_neighbor_elem"
      // so it needs to reinit on displaced neighbors and faces
      // _reinit_displaced_elem -> _current_elem will be reinited
      // _reinit_displaced_face -> _current_elem, lowerD if any and _current_side_elem to be
      // reinited _reinit_displaced_neighbor -> _current_elem, lowerD if any and _current_neighbor
      // to be reinited Note that as soon as you use materials on the displaced mesh, all three get
      // turned on.
      if (euo || nuo || duo)
        _reinit_displaced_elem = true;
      if (suo || duo || isuo || iuo)
        _reinit_displaced_face = true;
      if (iuo || duo || isuo)
        _reinit_displaced_neighbor = true;
    }
 
    // These objects only require one thread
    if ((guo && !tguo) || muo)
      break;
  }
 
  // Add as a Functor if it is one. We usually need to add the user object from thread 0 as the
  // registered functor for all threads because when user objects are thread joined, generally only
  // the primary thread copy ends up with all the data
  for (const auto tid : make_range(numThreads()))
  {
    const decltype(uos)::size_type uo_index = uos.front()->needThreadedCopy() ? tid : 0;
    if (const auto functor = dynamic_cast<Moose::FunctorBase<Real> *>(uos[uo_index].get()))
    {
      this->addFunctor(name, *functor, tid);
      if (_displaced_problem)
        _displaced_problem->addFunctor(name, *functor, tid);
    }
  }
 
  return uos;
}

Referenced by addPostprocessor(), addReporter(), PhysicsBase::addUserObject(), and addVectorPostprocessor().

◆ addVariable()

void FEProblemBase::addVariable	(	const std::string &	var_type,
		const std::string &	var_name,
		InputParameters &	params
	)

virtual

Canonical method for adding a non-linear variable.

Parameters

var_type	the type of the variable, e.g. MooseVariableScalar
var_name	the variable name, e.g. 'u'
params	the InputParameters from which to construct the variable

Reimplemented in MFEMEigenproblem, MFEMProblem, and DumpObjectsProblem.

Definition at line 3097 of file FEProblemBase.C.

{
  parallel_object_only();
 
  const auto fe_type = MooseUtils::variableFEType(params);
 
  const auto active_subdomains_vector =
      _mesh.getSubdomainIDs(params.get<std::vector<SubdomainName>>("block"));
  const std::set<SubdomainID> active_subdomains(active_subdomains_vector.begin(),
                                                active_subdomains_vector.end());
 
  if (duplicateVariableCheck(var_name, fe_type, /* is_aux = */ false, &active_subdomains))
    return;
 
  params.set<FEProblemBase *>("_fe_problem_base") = this;
  params.set<Moose::VarKindType>("_var_kind") = Moose::VarKindType::VAR_SOLVER;
  SolverSystemName sys_name = params.get<SolverSystemName>("solver_sys");
 
  const auto solver_system_number = solverSysNum(sys_name);
  logAdd("Variable", var_name, var_type, params);
  _solver_systems[solver_system_number]->addVariable(var_type, var_name, params);
  if (_displaced_problem)
    // MooseObjects need to be unique so change the name here
    _displaced_problem->addVariable(var_type, var_name, params, solver_system_number);
 
  _solver_var_to_sys_num[var_name] = solver_system_number;
}

Referenced by MFEMProblem::addGridFunction(), DiffusionCG::addSolverVariables(), DiffusionFV::addSolverVariables(), and AddVariableAction::init().

◆ addVectorPostprocessor()

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

virtual

Reimplemented in MFEMProblem.

Definition at line 4680 of file FEProblemBase.C.

{
  checkUserObjectNameCollision(name, "VectorPostprocessor");
 
  addUserObject(pp_name, name, parameters);
}

Referenced by MFEMProblem::addVectorPostprocessor(), and ExtraIDIntegralReporter::ExtraIDIntegralReporter().

◆ addVectorTag()

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

virtualinherited

Create a Tag.

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

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

Parameters

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

Reimplemented in DisplacedProblem.

Definition at line 84 of file SubProblem.C.

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

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

◆ advanceMultiApps()

void FEProblemBase::advanceMultiApps ( ExecFlagType type )

inline

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

Definition at line 1755 of file FEProblemBase.h.

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

◆ advanceState()

void FEProblemBase::advanceState ( )

virtual

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

Reimplemented in DumpObjectsProblem.

Definition at line 7494 of file FEProblemBase.C.

{
  TIME_SECTION("advanceState", 5, "Advancing State");
 
  for (auto & sys : _solver_systems)
    sys->advanceStateHistory(Moose::SolutionIterationType::Time);
  _aux->advanceStateHistory(Moose::SolutionIterationType::Time);
 
  if (_displaced_problem)
  {
    for (const auto i : index_range(_solver_systems))
      _displaced_problem->solverSys(i).advanceStateHistory(Moose::SolutionIterationType::Time);
    _displaced_problem->auxSys().advanceStateHistory(Moose::SolutionIterationType::Time);
  }
 
  _reporter_data.copyValuesBack();
 
  getMooseApp().getChainControlDataSystem().copyValuesBack();
 
  if (_material_props.hasStatefulProperties())
    _material_props.shift();
 
  if (_bnd_material_props.hasStatefulProperties())
    _bnd_material_props.shift();
 
  if (_neighbor_material_props.hasStatefulProperties())
    _neighbor_material_props.shift();
 
#ifdef MOOSE_KOKKOS_ENABLED
  if (_kokkos_material_props.hasStatefulProperties())
    _kokkos_material_props.shift();
 
  if (_kokkos_bnd_material_props.hasStatefulProperties())
    _kokkos_bnd_material_props.shift();
 
  if (_kokkos_neighbor_material_props.hasStatefulProperties())
    _kokkos_neighbor_material_props.shift();
#endif
 
  backupGeometricSearchState();
}

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

◆ allowInvalidSolution()

bool FEProblemBase::allowInvalidSolution ( ) const

inline

Whether to accept / allow an invalid solution.

Definition at line 2478 of file FEProblemBase.h.

2478{ return _allow_invalid_solution; }

Referenced by acceptInvalidSolution().

◆ allowMeshContractionAfterMeshChanged()

virtual bool FEProblemBase::allowMeshContractionAfterMeshChanged ( ) const

inlinevirtual

Whether meshChanged() should allow the mesh to be contracted (deletes children of coarsened elements and renumbers nodes and elements).

This should be overriden with care as disabling contraction may result in a substantial increase in the memory footprint of the mesh.

Definition at line 2219 of file FEProblemBase.h.

2219{ return true; }

Referenced by meshChanged().

◆ allowOutput() [1/2]

void FEProblemBase::allowOutput ( bool state )

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

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

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

◆ allowOutput() [2/2]

template<typename T >

void FEProblemBase::allowOutput ( bool state )

Definition at line 3772 of file FEProblemBase.h.

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

◆ areCoupled()

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

Definition at line 7021 of file FEProblemBase.C.

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

Referenced by MortarScalarBase::computeJacobian(), ODEKernel::computeJacobian(), NonlinearSystemBase::computeNodalBCsJacobian(), ComputeFullJacobianThread::computeOnBoundary(), ComputeFullJacobianThread::computeOnElement(), KernelScalarBase::computeResidualAndJacobian(), and NonlinearSystemBase::constraintJacobians().

◆ assembly() [1/2]

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

inlineoverridevirtual

Implements SubProblem.

Definition at line 3929 of file FEProblemBase.h.

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

◆ assembly() [2/2]

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

inlineoverridevirtual

Implements SubProblem.

Definition at line 3920 of file FEProblemBase.h.

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

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

◆ automaticScaling() [1/3]

bool SubProblem::automaticScaling ( ) const

Automatic scaling getter.

Returns: A boolean representing whether we are performing automatic scaling

Definition at line 845 of file SubProblem.C.

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

◆ automaticScaling() [2/3]

void SubProblem::automaticScaling ( bool automatic_scaling )

virtual

Automatic scaling setter.

Parameters

automatic_scaling A boolean representing whether we are performing automatic scaling

Reimplemented from SubProblem.

Definition at line 839 of file SubProblem.C.

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

◆ automaticScaling() [3/3]

void FEProblemBase::automaticScaling ( bool automatic_scaling )

overridevirtual

Automatic scaling setter.

Parameters

automatic_scaling A boolean representing whether we are performing automatic scaling

Reimplemented from SubProblem.

Definition at line 10057 of file FEProblemBase.C.

{
  if (_displaced_problem)
    _displaced_problem->automaticScaling(automatic_scaling);
 
  SubProblem::automaticScaling(automatic_scaling);
}

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

◆ backupGeometricSearchState()

void FEProblemBase::backupGeometricSearchState ( )

Snapshot geometric search state (both on the regular and, if present, the displaced mesh) so it can be restored with restoreGeometricSearchState() if this step is later rejected.

Called from advanceState(), i.e. before this step's timestepSetup() has run.

Definition at line 7537 of file FEProblemBase.C.

{
  _geometric_search_data.backup();
 
  if (_displaced_problem)
    _displaced_problem->geomSearchData().backup();
}

Referenced by advanceState().

◆ backupMultiApps()

void FEProblemBase::backupMultiApps ( ExecFlagType type )

Backup the MultiApps associated with the ExecFlagType.

Definition at line 6400 of file FEProblemBase.C.

{
  const auto & multi_apps = _multi_apps[type].getActiveObjects();
 
  if (multi_apps.size())
  {
    TIME_SECTION("backupMultiApps", 5, "Backing Up MultiApp");
 
    if (_verbose_multiapps)
      _console << COLOR_CYAN << "\nBacking Up MultiApps on " << type.name() << COLOR_DEFAULT
               << std::endl;
 
    for (const auto & multi_app : multi_apps)
      multi_app->backup();
 
    MooseUtils::parallelBarrierNotify(_communicator, _parallel_barrier_messaging);
 
    if (_verbose_multiapps)
      _console << COLOR_CYAN << "Finished Backing Up MultiApps on " << type.name() << "\n"
               << COLOR_DEFAULT << std::endl;
  }
}

Referenced by FixedPointSolve::solve().

◆ bumpAllQRuleOrder()

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

Definition at line 6878 of file FEProblemBase.C.

{
  for (unsigned int tid = 0; tid < numThreads(); ++tid)
    for (const auto i : index_range(_nl))
      _assembly[tid][i]->bumpAllQRuleOrder(order, block);
 
  if (_displaced_problem)
    _displaced_problem->bumpAllQRuleOrder(order, block);
 
  updateMaxQps();
}

Referenced by bumpAllQRuleOrder().

◆ bumpVolumeQRuleOrder()

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

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

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

Definition at line 6865 of file FEProblemBase.C.

{
  for (unsigned int tid = 0; tid < numThreads(); ++tid)
    for (const auto i : index_range(_nl))
      _assembly[tid][i]->bumpVolumeQRuleOrder(order, block);
 
  if (_displaced_problem)
    _displaced_problem->bumpVolumeQRuleOrder(order, block);
 
  updateMaxQps();
}

Referenced by bumpVolumeQRuleOrder().

◆ cacheJacobian()

void FEProblemBase::cacheJacobian ( const THREAD_ID tid )

overridevirtual

Reimplemented from SubProblem.

Definition at line 2223 of file FEProblemBase.C.

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

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

◆ cacheJacobianNeighbor()

void FEProblemBase::cacheJacobianNeighbor ( const THREAD_ID tid )

overridevirtual

Reimplemented from SubProblem.

Definition at line 2231 of file FEProblemBase.C.

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

Referenced by NonlinearSystemBase::constraintJacobians().

◆ cacheResidual()

void FEProblemBase::cacheResidual ( const THREAD_ID tid )

overridevirtual

Reimplemented from SubProblem.

Definition at line 2094 of file FEProblemBase.C.

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

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

◆ cacheResidualNeighbor()

void FEProblemBase::cacheResidualNeighbor ( const THREAD_ID tid )

overridevirtual

Reimplemented from SubProblem.

Definition at line 2102 of file FEProblemBase.C.

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

Referenced by NonlinearSystemBase::constraintResiduals().

◆ callMooseError() [1/2]

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

staticinherited

External method for calling moose error with added object context.

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

Parameters

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

Definition at line 114 of file MooseBase.C.

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

◆ callMooseError() [2/2]

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

inherited

External method for calling moose error with added object context.

Parameters

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

Definition at line 105 of file MooseBase.C.

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

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

◆ checkBlockMatProps()

void SubProblem::checkBlockMatProps ( )

virtualinherited

Checks block material properties integrity.

See also: FEProblemBase::checkProblemIntegrity

Definition at line 615 of file SubProblem.C.

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

Referenced by checkProblemIntegrity().

◆ checkBoundaryMatProps()

void SubProblem::checkBoundaryMatProps ( )

virtualinherited

Checks boundary material properties integrity.

See also: FEProblemBase::checkProblemIntegrity

Definition at line 657 of file SubProblem.C.

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

Referenced by checkProblemIntegrity().

◆ checkCoordinateSystems()

void FEProblemBase::checkCoordinateSystems ( )

protected

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

Definition at line 9623 of file FEProblemBase.C.

{
  _mesh.checkCoordinateSystems();
}

Referenced by checkProblemIntegrity().

◆ checkDependMaterialsHelper()

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

protected

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

{
  for (const auto & it : materials_map)
  {
    std::set<std::string> block_depend_props, block_supplied_props;
 
    for (const auto & mat1 : it.second)
    {
      auto & alldeps = mat1->getMatPropDependencies(); // includes requested stateful props
      for (auto & dep : alldeps)
        block_depend_props.insert(_material_prop_registry.getName(dep));
 
      // See if any of the active materials supply this property
      for (const auto & mat2 : it.second)
      {
        const std::set<std::string> & supplied_props = mat2->MaterialBase::getSuppliedItems();
        block_supplied_props.insert(supplied_props.begin(), supplied_props.end());
      }
    }
 
    // Add zero material properties specific to this block and unrestricted
    block_supplied_props.insert(_zero_block_material_props[it.first].begin(),
                                _zero_block_material_props[it.first].end());
 
    // Error check to make sure all properties consumed by materials are supplied on this block
    std::set<std::string> difference;
    std::set_difference(block_depend_props.begin(),
                        block_depend_props.end(),
                        block_supplied_props.begin(),
                        block_supplied_props.end(),
                        std::inserter(difference, difference.end()));
 
    if (!difference.empty())
    {
      std::ostringstream oss;
      oss << "One or more Material Properties were not supplied on block ";
      const std::string & subdomain_name = _mesh.getSubdomainName(it.first);
      if (subdomain_name.length() > 0)
        oss << subdomain_name << " (" << it.first << ")";
      else
        oss << it.first;
      oss << ":\n";
      for (const auto & name : difference)
        oss << name << "\n";
      mooseError(oss.str());
    }
  }
 
  // This loop checks that materials are not supplied by multiple Material objects
  for (const auto & it : materials_map)
  {
    const auto & materials = it.second;
    std::set<std::string> inner_supplied, outer_supplied;
 
    for (const auto & outer_mat : materials)
    {
      // Storage for properties for this material (outer) and all other materials (inner)
      outer_supplied = outer_mat->getSuppliedItems();
      inner_supplied.clear();
 
      // Property to material map for error reporting
      std::map<std::string, std::set<std::string>> prop_to_mat;
      for (const auto & name : outer_supplied)
        prop_to_mat[name].insert(outer_mat->name());
 
      for (const auto & inner_mat : materials)
      {
        if (outer_mat == inner_mat)
          continue;
 
        // Check whether these materials are an AD pair
        auto outer_mat_type = outer_mat->type();
        auto inner_mat_type = inner_mat->type();
        removeSubstring(outer_mat_type, "<RESIDUAL>");
        removeSubstring(outer_mat_type, "<JACOBIAN>");
        removeSubstring(inner_mat_type, "<RESIDUAL>");
        removeSubstring(inner_mat_type, "<JACOBIAN>");
        if (outer_mat_type == inner_mat_type && outer_mat_type != outer_mat->type() &&
            inner_mat_type != inner_mat->type())
          continue;
 
        inner_supplied.insert(inner_mat->getSuppliedItems().begin(),
                              inner_mat->getSuppliedItems().end());
 
        for (const auto & inner_supplied_name : inner_supplied)
          prop_to_mat[inner_supplied_name].insert(inner_mat->name());
      }
 
      // Test that a property isn't supplied on multiple blocks
      std::set<std::string> intersection;
      std::set_intersection(outer_supplied.begin(),
                            outer_supplied.end(),
                            inner_supplied.begin(),
                            inner_supplied.end(),
                            std::inserter(intersection, intersection.end()));
 
      if (!intersection.empty())
      {
        std::ostringstream oss;
        oss << "The following material properties are declared on block " << it.first
            << " by multiple materials:\n";
        oss << ConsoleUtils::indent(2) << std::setw(30) << std::left << "Material Property"
            << "Material Objects\n";
        for (const auto & outer_name : intersection)
        {
          oss << ConsoleUtils::indent(2) << std::setw(30) << std::left << outer_name;
          for (const auto & inner_name : prop_to_mat[outer_name])
            oss << inner_name << " ";
          oss << '\n';
        }
 
        mooseError(oss.str());
        break;
      }
    }
  }
}

Referenced by checkProblemIntegrity().

◆ checkDisplacementOrders()

void FEProblemBase::checkDisplacementOrders ( )

protected

Verify that SECOND order mesh uses SECOND order displacements.

Definition at line 9417 of file FEProblemBase.C.

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

Referenced by checkProblemIntegrity().

◆ checkDuplicatePostprocessorVariableNames()

void FEProblemBase::checkDuplicatePostprocessorVariableNames ( )

Definition at line 1685 of file FEProblemBase.C.

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

Referenced by checkProblemIntegrity().

◆ checkExceptionAndStopSolve()

void FEProblemBase::checkExceptionAndStopSolve ( bool print_message = true )

virtual

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

Notes:

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

Parameters

print_message whether to print a message with exception information

Definition at line 7315 of file FEProblemBase.C.

{
  if (_skip_exception_check)
    return;
 
  TIME_SECTION("checkExceptionAndStopSolve", 5);
 
  // See if any processor had an exception.  If it did, get back the
  // processor that the exception occurred on.
  unsigned int processor_id;
 
  _communicator.maxloc(_has_exception, processor_id);
 
  if (_has_exception)
  {
    _communicator.broadcast(_exception_message, processor_id);
 
    if (Moose::isSolverExecFlag(_current_execute_on_flag))
    {
      // Print the message
      if (_communicator.rank() == 0 && print_message)
      {
        _console << "\n" << _exception_message << "\n";
        if (isTransient())
          _console
              << "To recover, the solution will fail and then be re-attempted with a reduced time "
                 "step.\n"
              << std::endl;
      }
 
      // Stop the solve -- this entails setting
      // SNESSetFunctionDomainError() or directly inserting NaNs in the
      // residual vector to let PETSc >= 3.6 return DIVERGED_NANORINF.
      if (_current_nl_sys)
        _current_nl_sys->stopSolve(_current_execute_on_flag, _fe_vector_tags);
 
      if (_current_linear_sys)
        _current_linear_sys->stopSolve(_current_execute_on_flag, _fe_vector_tags);
 
      // and close Aux system (we MUST do this here; see #11525)
      _aux->solution().close();
 
      // We've handled this exception, so we no longer have one.
      _has_exception = false;
 
      // Force the next non-linear convergence check to fail (and all further residual evaluation
      // to be skipped).
      _fail_next_system_convergence_check = true;
 
      // Repropagate the exception, so it can be caught at a higher level, typically
      // this is NonlinearSystem::computeResidual().
      throw MooseException(_exception_message);
    }
    else
      mooseError("The following parallel-communicated exception was detected during " +
                 Moose::stringify(_current_execute_on_flag) + " evaluation:\n" +
                 _exception_message +
                 "\nBecause this did not occur during residual evaluation, there"
                 " is no way to handle this, so the solution is aborting.\n");
  }
}

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

◆ checkGradientMethods()

void FEProblemBase::checkGradientMethods ( )

protected

Let every FVGradientMethod resolve its dependencies on other gradient methods.

Definition at line 9493 of file FEProblemBase.C.

{
  std::vector<FVGradientMethod *> methods;
  theWarehouse().query().condition<AttribSystem>("FVGradientMethod").queryInto(methods);
  for (auto * method : methods)
    method->resolveGradientMethodDependencies(*this);
}

Referenced by checkProblemIntegrity().

◆ checkICRestartError()

void FEProblemBase::checkICRestartError	(	const std::string &	ic_name,
		const std::string &	name,
		const VariableName &	var_name
	)

private

Checks if the variable of the initial condition is getting restarted and errors for specific cases.

Parameters

ic_name	The name of the initial condition
var_name	The name of the variable

Definition at line 3751 of file FEProblemBase.C.

{
  if (!_allow_ics_during_restart)
  {
    std::string restart_method = "";
    if (_app.isRestarting())
      restart_method =
          "a checkpoint restart, by IC object '" + ic_name + "' for variable '" + name + "'";
    else if (_app.getExReaderForRestart())
    {
      std::vector<std::string> restarted_vars = _app.getExReaderForRestart()->get_elem_var_names();
      const auto nodal_vars = _app.getExReaderForRestart()->get_nodal_var_names();
      const auto global_vars = _app.getExReaderForRestart()->get_global_var_names();
      restarted_vars.insert(restarted_vars.end(), nodal_vars.begin(), nodal_vars.end());
      restarted_vars.insert(restarted_vars.end(), global_vars.begin(), global_vars.end());
 
      if (std::find(restarted_vars.begin(), restarted_vars.end(), var_name) != restarted_vars.end())
        restart_method = "an Exodus restart, by IC object '" + ic_name + "' for variable '" + name +
                         "' that is also being restarted";
    }
    if (!restart_method.empty())
      mooseError(
          "Initial conditions have been specified during ",
          restart_method,
          ".\nThis is only allowed if you specify 'allow_initial_conditions_with_restart' to "
          "the [Problem], as initial conditions can override restarted fields");
  }
}

Referenced by addFVInitialCondition(), and addInitialCondition().

◆ checkingUOAuxState()

bool FEProblemBase::checkingUOAuxState ( ) const

inline

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

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

Definition at line 229 of file FEProblemBase.h.

229{ return _checking_uo_aux_state; }

FEProblemBase::_checking_uo_aux_state

bool _checking_uo_aux_state

Flag used to indicate whether we are doing the uo/aux state check in execute.

Definition FEProblemBase.h:3726

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

◆ checkNonlocalCoupling()

void FEProblemBase::checkNonlocalCoupling ( )

Returns: Flag indicating nonlocal coupling exists or not.

Definition at line 1824 of file FEProblemBase.C.

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

◆ checkNonlocalCouplingRequirement()

bool FEProblemBase::checkNonlocalCouplingRequirement ( ) const

overridevirtual

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

Implements SubProblem.

Definition at line 10491 of file FEProblemBase.C.

{
  return _requires_nonlocal_coupling;
}

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

◆ checkProblemIntegrity()

void FEProblemBase::checkProblemIntegrity ( )

virtual

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

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

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

unsigned int is necessary to print SubdomainIDs in the statement below

vector is necessary to get the subdomain names

Reimplemented in EigenProblem.

Definition at line 9243 of file FEProblemBase.C.

{
  TIME_SECTION("checkProblemIntegrity", 5);
 
  // Subdomains specified by the "Problem/block" parameter
  const auto & subdomain_names = getParam<std::vector<SubdomainName>>("block");
  auto mesh_subdomains_vec = MooseMeshUtils::getSubdomainIDs(_mesh, subdomain_names);
  std::set<SubdomainID> mesh_subdomains(mesh_subdomains_vec.begin(), mesh_subdomains_vec.end());
 
  // Check kernel coverage of subdomains (blocks) in the mesh
  if (!_skip_nl_system_check && _solve && _kernel_coverage_check != CoverageCheckMode::FALSE &&
      _kernel_coverage_check != CoverageCheckMode::OFF)
  {
    std::set<SubdomainID> blocks;
    if (_kernel_coverage_check == CoverageCheckMode::TRUE ||
        _kernel_coverage_check == CoverageCheckMode::ON)
      blocks = mesh_subdomains;
    else if (_kernel_coverage_check == CoverageCheckMode::SKIP_LIST)
    {
      blocks = mesh_subdomains;
      for (const auto & subdomain_name : _kernel_coverage_blocks)
      {
        const auto id = _mesh.getSubdomainID(subdomain_name);
        if (id == Moose::INVALID_BLOCK_ID)
          paramError("kernel_coverage_block_list",
                     "Subdomain \"",
                     subdomain_name,
                     "\" not found in mesh.");
        blocks.erase(id);
      }
    }
    else if (_kernel_coverage_check == CoverageCheckMode::ONLY_LIST)
      for (const auto & subdomain_name : _kernel_coverage_blocks)
      {
        const auto id = _mesh.getSubdomainID(subdomain_name);
        if (id == Moose::INVALID_BLOCK_ID)
          paramError("kernel_coverage_block_list",
                     "Subdomain \"",
                     subdomain_name,
                     "\" not found in mesh.");
        blocks.insert(id);
      }
    if (!blocks.empty())
      for (auto & nl : _nl)
        nl->checkKernelCoverage(blocks);
  }
 
  // Check materials
  {
#ifdef LIBMESH_ENABLE_AMR
    if ((_adaptivity.isOn() || _num_grid_steps) &&
        (_material_props.hasStatefulProperties() || _bnd_material_props.hasStatefulProperties() ||
         _neighbor_material_props.hasStatefulProperties()))
    {
      _console << "Using EXPERIMENTAL Stateful Material Property projection with Adaptivity!\n"
               << std::flush;
    }
#endif
 
    std::set<SubdomainID> local_mesh_subs(mesh_subdomains);
 
    if (_material_coverage_check != CoverageCheckMode::FALSE &&
        _material_coverage_check != CoverageCheckMode::OFF)
    {
      bool check_material_coverage = false;
      std::set<SubdomainID> ids = _all_materials.getActiveBlocks();
      for (const auto & id : ids)
      {
        local_mesh_subs.erase(id);
        check_material_coverage = true;
      }
 
      // did the user limit the subdomains to be checked?
      if (_material_coverage_check == CoverageCheckMode::SKIP_LIST)
      {
        for (const auto & subdomain_name : _material_coverage_blocks)
        {
          const auto id = _mesh.getSubdomainID(subdomain_name);
          if (id == Moose::INVALID_BLOCK_ID)
            paramError("material_coverage_block_list",
                       "Subdomain \"" + subdomain_name + "\" not found in mesh.");
          local_mesh_subs.erase(id);
        }
      }
      else if (_material_coverage_check == CoverageCheckMode::ONLY_LIST)
      {
        std::set<SubdomainID> blocks(local_mesh_subs);
        for (const auto & subdomain_name : _material_coverage_blocks)
        {
          const auto id = _mesh.getSubdomainID(subdomain_name);
          if (id == Moose::INVALID_BLOCK_ID)
            paramError("material_coverage_block_list",
                       "Subdomain \"" + subdomain_name + "\" not found in mesh.");
          blocks.erase(id);
        }
        for (const auto id : blocks)
          local_mesh_subs.erase(id);
      }
 
      // also exclude mortar spaces from the material check
      auto && mortar_subdomain_ids = _mortar_data->getMortarSubdomainIDs();
      for (auto subdomain_id : mortar_subdomain_ids)
        local_mesh_subs.erase(subdomain_id);
 
      // Check Material Coverage
      if (check_material_coverage && !local_mesh_subs.empty())
      {
        std::stringstream extra_subdomain_ids;
        std::copy(local_mesh_subs.begin(),
                  local_mesh_subs.end(),
                  std::ostream_iterator<unsigned int>(extra_subdomain_ids, " "));
        std::vector<SubdomainID> local_mesh_subs_vec(local_mesh_subs.begin(),
                                                     local_mesh_subs.end());
 
        mooseError("The following blocks from your input mesh do not contain an active material: " +
                   extra_subdomain_ids.str() +
                   "(names: " + Moose::stringify(_mesh.getSubdomainNames(local_mesh_subs_vec)) +
                   ")\nWhen ANY mesh block contains a Material object, "
                   "all blocks must contain a Material object.\n");
      }
    }
 
    // Check material properties on blocks and boundaries
    checkBlockMatProps();
    checkBoundaryMatProps();
 
    // Check that material properties exist when requested by other properties on a given block
    const auto & materials = _all_materials.getActiveObjects();
    for (const auto & material : materials)
      material->checkStatefulSanity();
 
    // auto mats_to_check = _materials.getActiveBlockObjects();
    // const auto & discrete_materials = _discrete_materials.getActiveBlockObjects();
    // for (const auto & map_it : discrete_materials)
    //   for (const auto & container_element : map_it.second)
    //     mats_to_check[map_it.first].push_back(container_element);
    if (_material_dependency_check)
      checkDependMaterialsHelper(_all_materials.getActiveBlockObjects());
  }
 
  checkUserObjects();
 
  checkGradientMethods();
 
  // Verify that we don't have any Element type/Coordinate Type conflicts
  checkCoordinateSystems();
 
  // Coordinate transforms are only intended for use with MultiApps at this time. If you are not
  // using multiapps but still require these, contact a moose developer
  if (_mesh.coordTransform().hasScalingOrRotationTransformation() && _app.isUltimateMaster() &&
      !hasMultiApps())
    mooseError("Coordinate transformation parameters, listed below, are only to be used in the "
               "context of application to application field transfers at this time. The mesh is "
               "not modified by these parameters within an application.\n"
               "You should likely use a 'TransformGenerator' in the [Mesh] block to achieve the "
               "desired mesh modification.\n\n",
               Moose::stringify(MooseAppCoordTransform::validParams()));
 
  // If using displacements, verify that the order of the displacement
  // variables matches the order of the elements in the displaced
  // mesh.
  checkDisplacementOrders();
 
  // Check for postprocessor names with same name as a scalar variable
  checkDuplicatePostprocessorVariableNames();
}

Referenced by EigenProblem::checkProblemIntegrity().

◆ checkResidualForNans()

virtual bool FEProblemBase::checkResidualForNans ( ) const

inlineoverridevirtual

Whether to check residual for NaN/Inf values.

Implements SubProblem.

Definition at line 232 of file FEProblemBase.h.

232{ return _check_residual_for_nans; }

Referenced by DisplacedProblem::checkResidualForNans().

◆ checkUserObjectJacobianRequirement()

void FEProblemBase::checkUserObjectJacobianRequirement ( THREAD_ID tid )

Definition at line 1862 of file FEProblemBase.C.

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

◆ checkUserObjectNameCollision()

void FEProblemBase::checkUserObjectNameCollision	(	const std::string &	name,
		const std::string &	type
	)		const

Check for name collision between different user objects.

Parameters

name	The object name being added
type	The object type being added

Definition at line 4649 of file FEProblemBase.C.

{
  if (hasUserObject(name))
    mooseError("A ",
               getUserObjectBase(name).typeAndName(),
               " already exists. You may not add a ",
               type,
               " by the same name.");
 
#ifdef MOOSE_KOKKOS_ENABLED
  if (hasKokkosUserObject(name))
    mooseError("A ",
               getKokkosUserObject<UserObjectBase>(name).typeAndName(),
               " already exists. You may not add a ",
               type,
               " by the same name.");
#endif
}

Referenced by addPostprocessor(), MFEMProblem::addPostprocessor(), addReporter(), addVectorPostprocessor(), and MFEMProblem::addVectorPostprocessor().

◆ checkUserObjects()

void FEProblemBase::checkUserObjects ( )

protected

Definition at line 9458 of file FEProblemBase.C.

{
  // Check user_objects block coverage
  std::set<SubdomainID> mesh_subdomains = _mesh.meshSubdomains();
  std::set<SubdomainID> user_objects_blocks;
 
  // gather names of all user_objects that were defined in the input file
  // and the blocks that they are defined on
  std::set<std::string> names;
 
  std::vector<UserObjectBase *> objects;
  theWarehouse().query().condition<AttribInterfaces>(Interfaces::UserObject).queryInto(objects);
 
  for (const auto & obj : objects)
    names.insert(obj->name());
 
  // See if all referenced blocks are covered
  std::set<SubdomainID> difference;
  std::set_difference(user_objects_blocks.begin(),
                      user_objects_blocks.end(),
                      mesh_subdomains.begin(),
                      mesh_subdomains.end(),
                      std::inserter(difference, difference.end()));
 
  if (!difference.empty())
  {
    std::ostringstream oss;
    oss << "One or more UserObjects is referencing a nonexistent block:\n";
    for (const auto & id : difference)
      oss << id << "\n";
    mooseError(oss.str());
  }
}

Referenced by checkProblemIntegrity().

◆ clearActiveElementalMooseVariables()

void FEProblemBase::clearActiveElementalMooseVariables ( const THREAD_ID tid )

overridevirtual

Clear the active elemental MooseVariableFEBase.

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

Parameters

tid	The thread id

Reimplemented from SubProblem.

Definition at line 6707 of file FEProblemBase.C.

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

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

◆ clearActiveFEVariableCoupleableMatrixTags()

void FEProblemBase::clearActiveFEVariableCoupleableMatrixTags ( const THREAD_ID tid )

overridevirtual

Reimplemented from SubProblem.

Definition at line 6716 of file FEProblemBase.C.

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

◆ clearActiveFEVariableCoupleableVectorTags()

void FEProblemBase::clearActiveFEVariableCoupleableVectorTags ( const THREAD_ID tid )

overridevirtual

Reimplemented from SubProblem.

Definition at line 6725 of file FEProblemBase.C.

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

◆ clearActiveMaterialProperties()

void FEProblemBase::clearActiveMaterialProperties ( const THREAD_ID tid )

Clear the active material properties.

Should be called at the end of every computing thread

Parameters

tid	The thread id

Definition at line 6773 of file FEProblemBase.C.

{
  _has_active_material_properties[tid] = 0;
}

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

◆ clearActiveScalarVariableCoupleableMatrixTags()

void FEProblemBase::clearActiveScalarVariableCoupleableMatrixTags ( const THREAD_ID tid )

overridevirtual

Reimplemented from SubProblem.

Definition at line 6734 of file FEProblemBase.C.

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

Referenced by AuxiliarySystem::clearScalarVariableCoupleableTags().

◆ clearActiveScalarVariableCoupleableVectorTags()

void FEProblemBase::clearActiveScalarVariableCoupleableVectorTags ( const THREAD_ID tid )

overridevirtual

Reimplemented from SubProblem.

Definition at line 6743 of file FEProblemBase.C.

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

Referenced by AuxiliarySystem::clearScalarVariableCoupleableTags().

◆ clearAllDofIndices()

void SubProblem::clearAllDofIndices ( )

inherited

Clear dof indices from variables in nl and aux systems.

Definition at line 1178 of file SubProblem.C.

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

Referenced by solve().

◆ clearCurrentJacobianMatrixTags()

void FEProblemBase::clearCurrentJacobianMatrixTags ( )

inline

Clear the current Jacobian matrix tag data structure ... if someone creates it.

Definition at line 3028 of file FEProblemBase.h.

3028{}

Referenced by resetState().

◆ clearCurrentResidualVectorTags()

void FEProblemBase::clearCurrentResidualVectorTags ( )

inline

Clear the current residual vector tag data structure.

Definition at line 3966 of file FEProblemBase.h.

{
  _current_residual_vector_tags.clear();
}

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

◆ clearDiracInfo()

void FEProblemBase::clearDiracInfo ( )

overridevirtual

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

Implements SubProblem.

Definition at line 2686 of file FEProblemBase.C.

{
  _dirac_kernel_info.clearPoints();
 
  if (_displaced_problem)
    _displaced_problem->clearDiracInfo();
}

Referenced by NonlinearSystemBase::computeDiracContributions().

◆ cloneAlgebraicGhostingFunctor()

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

privateinherited

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

Parameters

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

Definition at line 1009 of file SubProblem.C.

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

Referenced by SubProblem::addAlgebraicGhostingFunctor().

◆ cloneCouplingGhostingFunctor()

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

privateinherited

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

Parameters

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

Definition at line 1043 of file SubProblem.C.

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

Referenced by SubProblem::addCouplingGhostingFunctor().

◆ computeBounds()

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

virtual

Definition at line 8393 of file FEProblemBase.C.

{
  try
  {
    try
    {
      mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
                  "I expect these system numbers to be the same");
 
      if (!_current_nl_sys->hasVector("lower_bound") || !_current_nl_sys->hasVector("upper_bound"))
        return;
 
      TIME_SECTION("computeBounds", 1, "Computing Bounds");
 
      NumericVector<Number> & _lower = _current_nl_sys->getVector("lower_bound");
      NumericVector<Number> & _upper = _current_nl_sys->getVector("upper_bound");
      _lower.swap(lower);
      _upper.swap(upper);
      for (THREAD_ID tid = 0; tid < numThreads(); tid++)
        _all_materials.residualSetup(tid);
 
      _aux->residualSetup();
      computeSystems(EXEC_LINEAR);
      _lower.swap(lower);
      _upper.swap(upper);
    }
    catch (...)
    {
      handleException("computeBounds");
    }
  }
  catch (MooseException & e)
  {
    mooseError("Irrecoverable exception: " + std::string(e.what()));
  }
  catch (...)
  {
    mooseError("Unexpected exception type");
  }
}

Referenced by Moose::compute_bounds().

◆ computeDamping()

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

virtual

Definition at line 8675 of file FEProblemBase.C.

{
  // Default to no damping
  Real damping = 1.0;
 
  if (_has_dampers)
  {
    TIME_SECTION("computeDamping", 1, "Computing Damping");
 
    // Save pointer to the current solution
    const NumericVector<Number> * _saved_current_solution = _current_nl_sys->currentSolution();
 
    _current_nl_sys->setSolution(soln);
    // For now, do not re-compute auxiliary variables.  Doing so allows a wild solution increment
    //   to get to the material models, which may not be able to cope with drastically different
    //   values.  Once more complete dependency checking is in place, auxiliary variables (and
    //   material properties) will be computed as needed by dampers.
    //    _aux.compute();
    damping = _current_nl_sys->computeDamping(soln, update);
 
    // restore saved solution
    _current_nl_sys->setSolution(*_saved_current_solution);
  }
 
  return damping;
}

Referenced by computePostCheck().

◆ computeIndicators()

void FEProblemBase::computeIndicators ( )

virtual

Reimplemented in DumpObjectsProblem.

Definition at line 5089 of file FEProblemBase.C.

{
  // Initialize indicator aux variable fields
  if (_indicators.hasActiveObjects() || _internal_side_indicators.hasActiveObjects())
  {
    TIME_SECTION("computeIndicators", 1, "Computing Indicators");
 
    // Internal side indicators may lead to creating a much larger sparsity pattern than dictated by
    // the actual finite element scheme (e.g. CFEM)
    const auto old_do_derivatives = ADReal::do_derivatives;
    ADReal::do_derivatives = false;
 
    std::vector<std::string> fields;
 
    // Indicator Fields
    const auto & indicators = _indicators.getActiveObjects();
    for (const auto & indicator : indicators)
      fields.push_back(indicator->name());
 
    // InternalSideIndicator Fields
    const auto & internal_indicators = _internal_side_indicators.getActiveObjects();
    for (const auto & internal_indicator : internal_indicators)
      fields.push_back(internal_indicator->name());
 
    _aux->zeroVariables(fields);
 
    // compute Indicators
    ComputeIndicatorThread cit(*this);
    Threads::parallel_reduce(getCurrentAlgebraicElementRange(), cit, numThreads());
    _aux->solution().close();
    _aux->update();
 
    ComputeIndicatorThread finalize_cit(*this, true);
    Threads::parallel_reduce(getCurrentAlgebraicElementRange(), finalize_cit, numThreads());
    _aux->solution().close();
    _aux->update();
 
    ADReal::do_derivatives = old_do_derivatives;
  }
}

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

◆ computeIndicatorsAndMarkers()

void FEProblemBase::computeIndicatorsAndMarkers ( )

virtual

Definition at line 5082 of file FEProblemBase.C.

{
  computeIndicators();
  computeMarkers();
}

◆ computeJacobian()

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

virtual

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

Reimplemented in EigenProblem.

Definition at line 8218 of file FEProblemBase.C.

{
  setCurrentNonlinearSystem(nl_sys_num);
 
  _fe_matrix_tags.clear();
 
  auto & tags = getMatrixTags();
  for (auto & tag : tags)
    _fe_matrix_tags.insert(tag.second);
 
  computeJacobianInternal(soln, jacobian, _fe_matrix_tags);
}

Referenced by computeJacobianSys().

◆ computeJacobianBlock()

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

virtual

Really not a good idea to use this.

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

Parameters

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

Definition at line 8381 of file FEProblemBase.C.

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

◆ computeJacobianBlocks()

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

virtual

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

Used by Physics-based preconditioning

Parameters

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

Reimplemented in EigenProblem.

Definition at line 8361 of file FEProblemBase.C.

{
  TIME_SECTION("computeTransientImplicitJacobian", 2);
  setCurrentNonlinearSystem(nl_sys_num);
 
  if (_displaced_problem)
  {
    computeSystems(EXEC_PRE_DISPLACE);
    _displaced_problem->updateMesh();
  }
 
  computeSystems(EXEC_NONLINEAR);
 
  _currently_computing_jacobian = true;
  _current_nl_sys->computeJacobianBlocks(blocks);
  _currently_computing_jacobian = false;
}

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

◆ computeJacobianInternal()

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

virtual

Form a Jacobian matrix for multiple tags.

It should not be called directly by users.

Definition at line 8234 of file FEProblemBase.C.

{
  TIME_SECTION("computeJacobianInternal", 1);
 
  _current_nl_sys->setSolution(soln);
 
  _current_nl_sys->associateMatrixToTag(jacobian, _current_nl_sys->systemMatrixTag());
 
  computeJacobianTags(tags);
 
  _current_nl_sys->disassociateMatrixFromTag(jacobian, _current_nl_sys->systemMatrixTag());
}

Referenced by computeJacobian().

◆ computeJacobianSys()

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

virtual

Form a Jacobian matrix.

It is called by Libmesh.

Definition at line 8194 of file FEProblemBase.C.

{
  // Reset before Jacobian setup, calculation & execution
  _app.solutionInvalidity().resetIterationOccurences();
  computeJacobian(soln, jacobian, sys.number());
}

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

◆ computeJacobianTag()

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

virtual

Form a Jacobian matrix for a given tag.

Definition at line 8204 of file FEProblemBase.C.

{
  _current_nl_sys->setSolution(soln);
 
  _current_nl_sys->associateMatrixToTag(jacobian, tag);
 
  computeJacobianTags({tag});
 
  _current_nl_sys->disassociateMatrixFromTag(jacobian, tag);
}

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

◆ computeJacobianTags()

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

virtual

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

Definition at line 8250 of file FEProblemBase.C.

{
  try
  {
    try
    {
      if (!_has_jacobian || !_const_jacobian)
      {
        TIME_SECTION("computeJacobianTags", 5, "Computing Jacobian");
 
        for (auto tag : tags)
          if (_current_nl_sys->hasMatrix(tag))
          {
            auto & matrix = _current_nl_sys->getMatrix(tag);
            if (_restore_original_nonzero_pattern)
              matrix.restore_original_nonzero_pattern();
            else
              matrix.zero();
            if (haveADObjects() && !_current_nl_sys->system().has_static_condensation())
              // PETSc algorithms require diagonal allocations regardless of whether there is
              // non-zero diagonal dependence. With global AD indexing we only add non-zero
              // dependence, so PETSc will scream at us unless we artificially add the diagonals.
              for (auto index : make_range(matrix.row_start(), matrix.row_stop()))
                matrix.add(index, index, 0);
          }
 
        _aux->zeroVariablesForJacobian();
 
        unsigned int n_threads = numThreads();
 
        // Random interface objects
        for (const auto & it : _random_data_objects)
          it.second->updateSeeds(EXEC_NONLINEAR);
 
        _current_execute_on_flag = EXEC_NONLINEAR;
        _currently_computing_jacobian = true;
        if (_displaced_problem)
          _displaced_problem->setCurrentlyComputingJacobian(true);
 
        execMultiApps(EXEC_NONLINEAR);
 
        for (unsigned int tid = 0; tid < n_threads; tid++)
          reinitScalars(tid);
 
        computeUserObjects(EXEC_NONLINEAR, Moose::PRE_AUX);
 
        _aux->jacobianSetup();
 
        if (_displaced_problem)
        {
          computeSystems(EXEC_PRE_DISPLACE);
          _displaced_problem->updateMesh();
          // A standalone scaling Jacobian is assembled without a preceding residual evaluation, so
          // the displaced mortar segment mesh can be stale relative to the just-updated displaced
          // parent mesh. Every other Jacobian evaluation is preceded by a residual (or combined
          // residual/Jacobian) evaluation that already rebuilt the mortar mesh, so doing it here in
          // the general case would be duplicative.
          if (_current_nl_sys->computingScalingJacobian() && _mortar_data->hasDisplacedObjects())
            updateMortarMesh();
        }
 
        for (unsigned int tid = 0; tid < n_threads; tid++)
        {
          _all_materials.jacobianSetup(tid);
          _functions.jacobianSetup(tid);
        }
 
#ifdef MOOSE_KOKKOS_ENABLED
        _kokkos_functions.jacobianSetup();
#endif
 
        computeSystems(EXEC_NONLINEAR);
 
        computeUserObjects(EXEC_NONLINEAR, Moose::POST_AUX);
 
        executeControls(EXEC_NONLINEAR);
 
        _app.getOutputWarehouse().jacobianSetup();
 
        _safe_access_tagged_matrices = false;
 
        _current_nl_sys->computeJacobianTags(tags);
 
        // For explicit Euler calculations for example we often compute the Jacobian one time and
        // then re-use it over and over. If we're performing automatic scaling, we don't want to
        // use that kernel, diagonal-block only Jacobian for our actual matrix when performing
        // solves!
        if (!_current_nl_sys->computingScalingJacobian())
          _has_jacobian = true;
      }
    }
    catch (...)
    {
      handleException("computeJacobianTags");
    }
  }
  catch (const MooseException &)
  {
    // The buck stops here, we have already handled the exception by
    // calling the system's stopSolve() method, it is now up to PETSc to return a
    // "diverged" reason during the next solve.
  }
  catch (...)
  {
    mooseError("Unexpected exception type");
  }
 
  resetState();
}

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

◆ computeKokkosUserObjectsInternal()

void FEProblemBase::computeKokkosUserObjectsInternal	(	const ExecFlagType &	type,
		TheWarehouse::Query &	query
	)

protected

Referenced by computeUserObjectByName(), and computeUserObjects().

◆ computeLinearSystemSys()

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

virtual

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

Parameters

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

Definition at line 8437 of file FEProblemBase.C.

{
  TIME_SECTION("computeLinearSystemSys", 5);
 
  setCurrentLinearSystem(linearSysNum(sys.name()));
 
  _current_linear_sys->associateVectorToTag(rhs, _current_linear_sys->rightHandSideVectorTag());
  _current_linear_sys->associateMatrixToTag(system_matrix, _current_linear_sys->systemMatrixTag());
 
  // We are using the residual tag system for right hand sides so we fetch everything
  const auto & vector_tags = getVectorTags(Moose::VECTOR_TAG_RESIDUAL);
 
  // We filter out tags which do not have associated vectors in the current
  // system. This is essential to be able to use system-dependent vector tags.
  selectVectorTagsFromSystem(*_current_linear_sys, vector_tags, _linear_vector_tags);
  selectMatrixTagsFromSystem(*_current_linear_sys, getMatrixTags(), _linear_matrix_tags);
 
  computeLinearSystemTags(*(_current_linear_sys->currentSolution()),
                          _linear_vector_tags,
                          _linear_matrix_tags,
                          compute_gradients);
 
  _current_linear_sys->disassociateMatrixFromTag(system_matrix,
                                                 _current_linear_sys->systemMatrixTag());
  _current_linear_sys->disassociateVectorFromTag(rhs,
                                                 _current_linear_sys->rightHandSideVectorTag());
  // We reset the tags to the default containers for further operations
  _current_linear_sys->associateVectorToTag(_current_linear_sys->getRightHandSideVector(),
                                            _current_linear_sys->rightHandSideVectorTag());
  _current_linear_sys->associateMatrixToTag(_current_linear_sys->getSystemMatrix(),
                                            _current_linear_sys->systemMatrixTag());
}

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

◆ computeLinearSystemTags()

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

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

Parameters

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

Definition at line 8474 of file FEProblemBase.C.

{
  TIME_SECTION("computeLinearSystemTags", 5, "Computing Linear System");
 
  _current_linear_sys->setSolution(soln);
 
  for (auto tag : matrix_tags)
  {
    auto & matrix = _current_linear_sys->getMatrix(tag);
    matrix.zero();
  }
 
  unsigned int n_threads = numThreads();
 
  _current_execute_on_flag = EXEC_NONLINEAR;
 
  // Random interface objects
  for (const auto & it : _random_data_objects)
    it.second->updateSeeds(EXEC_NONLINEAR);
 
  execMultiApps(EXEC_NONLINEAR);
 
  computeUserObjects(EXEC_NONLINEAR, Moose::PRE_AUX);
 
  _aux->jacobianSetup();
 
  for (THREAD_ID tid = 0; tid < n_threads; tid++)
  {
    _functions.jacobianSetup(tid);
  }
 
#ifdef MOOSE_KOKKOS_ENABLED
  _kokkos_functions.jacobianSetup();
#endif
 
  try
  {
    computeSystems(EXEC_NONLINEAR);
  }
  catch (MooseException & e)
  {
    _console << "\nA MooseException was raised during Auxiliary variable computation.\n"
             << "The next solve will fail, the timestep will be reduced, and we will try again.\n"
             << std::endl;
 
    // We know the next solve is going to fail, so there's no point in
    // computing anything else after this.  Plus, using incompletely
    // computed AuxVariables in subsequent calculations could lead to
    // other errors or unhandled exceptions being thrown.
    return;
  }
 
  computeUserObjects(EXEC_NONLINEAR, Moose::POST_AUX);
  executeControls(EXEC_NONLINEAR);
 
  _app.getOutputWarehouse().jacobianSetup();
 
  _current_linear_sys->computeLinearSystemTags(vector_tags, matrix_tags, compute_gradients);
 
  // Reset execution flag as after this point we are no longer on LINEAR
  _current_execute_on_flag = EXEC_NONE;
 
  // These are the relevant parts of resetState()
  _safe_access_tagged_vectors = true;
  _safe_access_tagged_matrices = true;
}

Referenced by computeLinearSystemSys().

◆ computeMarkers()

void FEProblemBase::computeMarkers ( )

virtual

Reimplemented in DumpObjectsProblem.

Definition at line 5131 of file FEProblemBase.C.

{
  if (_markers.hasActiveObjects())
  {
    TIME_SECTION("computeMarkers", 1, "Computing Markers");
 
    std::vector<std::string> fields;
 
    // Marker Fields
    const auto & markers = _markers.getActiveObjects();
    for (const auto & marker : markers)
      fields.push_back(marker->name());
 
    _aux->zeroVariables(fields);
 
    _adaptivity.updateErrorVectors();
 
    for (THREAD_ID tid = 0; tid < numThreads(); ++tid)
    {
      const auto & markers = _markers.getActiveObjects(tid);
      for (const auto & marker : markers)
        marker->markerSetup();
    }
 
    ComputeMarkerThread cmt(*this);
    Threads::parallel_reduce(getCurrentAlgebraicElementRange(), cmt, numThreads());
 
    _aux->solution().close();
    _aux->update();
  }
}

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

◆ computeMultiAppsDT()

Real FEProblemBase::computeMultiAppsDT ( ExecFlagType type )

Find the smallest timestep over all MultiApps.

Definition at line 6452 of file FEProblemBase.C.

{
  const auto & multi_apps = _transient_multi_apps[type].getActiveObjects();
 
  Real smallest_dt = std::numeric_limits<Real>::max();
 
  for (const auto & multi_app : multi_apps)
    smallest_dt = std::min(smallest_dt, multi_app->computeDT());
 
  return smallest_dt;
}

Referenced by TransientBase::constrainDTFromMultiApp().

◆ computeNearNullSpace()

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

virtual

Definition at line 8545 of file FEProblemBase.C.

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

Referenced by Moose::compute_nearnullspace().

◆ computeNullSpace()

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

virtual

Definition at line 8562 of file FEProblemBase.C.

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

Referenced by Moose::compute_nullspace().

◆ computePostCheck()

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

virtual

Definition at line 8592 of file FEProblemBase.C.

{
  mooseAssert(_current_nl_sys && (sys.number() == _current_nl_sys->number()),
              "I expect these system numbers to be the same");
 
  // This function replaces the old PetscSupport::dampedCheck() function.
  //
  // 1.) Recreate code in PetscSupport::dampedCheck() for constructing
  //     ghosted "soln" and "update" vectors.
  // 2.) Call FEProblemBase::computeDamping() with these ghost vectors.
  // 3.) Recreate the code in PetscSupport::dampedCheck() to actually update
  //     the solution vector based on the damping, and set the "changed" flags
  //     appropriately.
 
  TIME_SECTION("computePostCheck", 2, "Computing Post Check");
 
  _current_execute_on_flag = EXEC_POSTCHECK;
 
  // MOOSE's FEProblemBase doesn't update the solution during the
  // postcheck, but FEProblemBase-derived classes might.
  if (_has_dampers || shouldUpdateSolution())
  {
    // We need ghosted versions of new_soln and search_direction (the
    // ones we get from libmesh/PETSc are PARALLEL vectors.  To make
    // our lives simpler, we use the same ghosting pattern as the
    // system's current_local_solution to create new ghosted vectors.
 
    // Construct zeroed-out clones with the same ghosted dofs as the
    // System's current_local_solution.
    std::unique_ptr<NumericVector<Number>> ghosted_solution =
                                               sys.current_local_solution->zero_clone(),
                                           ghosted_search_direction =
                                               sys.current_local_solution->zero_clone();
 
    // Copy values from input vectors into clones with ghosted values.
    *ghosted_solution = new_soln;
    *ghosted_search_direction = search_direction;
 
    if (_has_dampers)
    {
      // Compute the damping coefficient using the ghosted vectors
      Real damping = computeDamping(*ghosted_solution, *ghosted_search_direction);
 
      // If some non-trivial damping was computed, update the new_soln
      // vector accordingly.
      if (damping < 1.0)
      {
        new_soln = old_soln;
        new_soln.add(-damping, search_direction);
        changed_new_soln = true;
      }
    }
 
    if (shouldUpdateSolution())
    {
      // Update the ghosted copy of the new solution, if necessary.
      if (changed_new_soln)
        *ghosted_solution = new_soln;
 
      bool updated_solution = updateSolution(new_soln, *ghosted_solution);
      if (updated_solution)
        changed_new_soln = true;
    }
  }
 
  if (vectorTagExists(Moose::PREVIOUS_NL_SOLUTION_TAG))
  {
    _current_nl_sys->setPreviousNewtonSolution(old_soln);
    _aux->copyCurrentIntoPreviousNL();
  }
 
  // MOOSE doesn't change the search_direction
  changed_search_direction = false;
 
  _current_execute_on_flag = EXEC_NONE;
}

Referenced by Moose::compute_postcheck().

◆ computeResidual() [1/2]

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

virtual

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

◆ computeResidual() [2/2]

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

This function is called by Libmesh to form a residual.

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

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

◆ computeResidualAndJacobian()

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

Form a residual and Jacobian with default tags.

Definition at line 7824 of file FEProblemBase.C.

{
  try
  {
    try
    {
      // vector tags
      _current_nl_sys->associateVectorToTag(residual, _current_nl_sys->residualVectorTag());
      const auto & residual_vector_tags = getVectorTags(Moose::VECTOR_TAG_RESIDUAL);
 
      mooseAssert(_fe_vector_tags.empty(),
                  "This should be empty indicating a clean starting state");
      // We filter out tags which do not have associated vectors in the current nonlinear
      // system. This is essential to be able to use system-dependent residual tags.
      selectVectorTagsFromSystem(*_current_nl_sys, residual_vector_tags, _fe_vector_tags);
 
      setCurrentResidualVectorTags(_fe_vector_tags);
 
      // matrix tags
      {
        _fe_matrix_tags.clear();
 
        auto & tags = getMatrixTags();
        for (auto & tag : tags)
          _fe_matrix_tags.insert(tag.second);
      }
 
      _current_nl_sys->setSolution(soln);
 
      _current_nl_sys->associateVectorToTag(residual, _current_nl_sys->residualVectorTag());
      _current_nl_sys->associateMatrixToTag(jacobian, _current_nl_sys->systemMatrixTag());
 
      for (const auto tag : _fe_matrix_tags)
        if (_current_nl_sys->hasMatrix(tag))
        {
          auto & matrix = _current_nl_sys->getMatrix(tag);
          matrix.zero();
          if (haveADObjects() && !_current_nl_sys->system().has_static_condensation())
            // PETSc algorithms require diagonal allocations regardless of whether there is non-zero
            // diagonal dependence. With global AD indexing we only add non-zero
            // dependence, so PETSc will scream at us unless we artificially add the diagonals.
            for (auto index : make_range(matrix.row_start(), matrix.row_stop()))
              matrix.add(index, index, 0);
        }
 
      _aux->zeroVariablesForResidual();
 
      unsigned int n_threads = numThreads();
 
      _current_execute_on_flag = EXEC_LINEAR;
 
      // Random interface objects
      for (const auto & it : _random_data_objects)
        it.second->updateSeeds(EXEC_LINEAR);
 
      setCurrentlyComputingResidual(true);
      setCurrentlyComputingJacobian(true);
      setCurrentlyComputingResidualAndJacobian(true);
      if (_displaced_problem)
      {
        _displaced_problem->setCurrentlyComputingResidual(true);
        _displaced_problem->setCurrentlyComputingJacobian(true);
        _displaced_problem->setCurrentlyComputingResidualAndJacobian(true);
      }
 
      execMultiApps(EXEC_LINEAR);
 
      for (unsigned int tid = 0; tid < n_threads; tid++)
        reinitScalars(tid);
 
      computeUserObjects(EXEC_LINEAR, Moose::PRE_AUX);
 
      _aux->residualSetup();
 
      if (_displaced_problem)
      {
        computeSystems(EXEC_PRE_DISPLACE);
        _displaced_problem->updateMesh();
        if (_mortar_data->hasDisplacedObjects())
          updateMortarMesh();
      }
 
      for (THREAD_ID tid = 0; tid < n_threads; tid++)
      {
        _all_materials.residualSetup(tid);
        _functions.residualSetup(tid);
      }
 
#ifdef MOOSE_KOKKOS_ENABLED
      _kokkos_functions.residualSetup();
#endif
 
      computeSystems(EXEC_LINEAR);
 
      computeUserObjects(EXEC_LINEAR, Moose::POST_AUX);
 
      executeControls(EXEC_LINEAR);
 
      _app.getOutputWarehouse().residualSetup();
 
      _safe_access_tagged_vectors = false;
      _safe_access_tagged_matrices = false;
 
      _current_nl_sys->computeResidualAndJacobianTags(_fe_vector_tags, _fe_matrix_tags);
 
      _current_nl_sys->disassociateMatrixFromTag(jacobian, _current_nl_sys->systemMatrixTag());
      _current_nl_sys->disassociateVectorFromTag(residual, _current_nl_sys->residualVectorTag());
    }
    catch (...)
    {
      handleException("computeResidualAndJacobian");
    }
  }
  catch (const MooseException &)
  {
    // The buck stops here, we have already handled the exception by
    // calling the system's stopSolve() method, it is now up to PETSc to return a
    // "diverged" reason during the next solve.
  }
  catch (...)
  {
    mooseError("Unexpected exception type");
  }
 
  resetState();
  _fe_vector_tags.clear();
  _fe_matrix_tags.clear();
}

Referenced by ComputeResidualAndJacobian::residual_and_jacobian().

◆ computeResidualInternal()

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

virtual

Form a residual vector for a set of tags.

It should not be called directly by users.

Definition at line 7985 of file FEProblemBase.C.

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

◆ computeResidualL2Norm() [1/3]

Real FEProblemBase::computeResidualL2Norm ( )

virtual

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

Returns: The L2 norm of the residual

Reimplemented in EigenProblem.

Definition at line 7757 of file FEProblemBase.C.

{
  TIME_SECTION("computeResidualL2Norm", 2, "Computing L2 Norm of Residual");
 
  // We use sum the squared norms of the individual systems and then take the square root of it
  Real l2_norm = 0.0;
  for (auto sys : _nl)
  {
    const auto norm = computeResidualL2Norm(*sys);
    l2_norm += norm * norm;
  }
 
  for (auto sys : _linear_systems)
  {
    const auto norm = computeResidualL2Norm(*sys);
    l2_norm += norm * norm;
  }
 
  return std::sqrt(l2_norm);
}

Referenced by computeResidualL2Norm().

◆ computeResidualL2Norm() [2/3]

Real FEProblemBase::computeResidualL2Norm ( LinearSystem & sys )

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

Definition at line 7739 of file FEProblemBase.C.

{
  _current_linear_sys = &sys;
 
  // We assemble the current system to check the current residual
  computeLinearSystemSys(sys.linearImplicitSystem(),
                         *sys.linearImplicitSystem().matrix,
                         *sys.linearImplicitSystem().rhs,
                         /*compute fresh gradients*/ true);
 
  // Unfortunate, but we have to allocate a new vector for the residual
  auto residual = sys.linearImplicitSystem().rhs->clone();
  residual->scale(-1.0);
  residual->add_vector(*sys.currentSolution(), *sys.linearImplicitSystem().matrix);
  return residual->l2_norm();
}

◆ computeResidualL2Norm() [3/3]

Real FEProblemBase::computeResidualL2Norm ( NonlinearSystemBase & sys )

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

Definition at line 7731 of file FEProblemBase.C.

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

Referenced by DefaultMultiAppFixedPointConvergence::checkConvergence(), Residual::getValue(), DefaultMultiAppFixedPointConvergence::preIteration(), and DefaultMultiAppFixedPointConvergence::preLoop().

◆ computeResidualSys()

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

virtual

This function is called by Libmesh to form a residual.

Definition at line 7779 of file FEProblemBase.C.

{
  parallel_object_only();
 
  TIME_SECTION("computeResidualSys", 5);
  // Reset before residual setup, calculation & execution
  _app.solutionInvalidity().resetIterationOccurences();
 
  computeResidual(soln, residual, sys.number());
}

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

◆ computeResidualTag()

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

virtual

Form a residual vector for a given tag.

Definition at line 7956 of file FEProblemBase.C.

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

◆ computeResidualTags()

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

virtual

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

Definition at line 8104 of file FEProblemBase.C.

{
  parallel_object_only();
 
  try
  {
    try
    {
      TIME_SECTION("computeResidualTags", 5, "Computing Residual");
 
      ADReal::do_derivatives = false;
 
      setCurrentResidualVectorTags(tags);
 
      _aux->zeroVariablesForResidual();
 
      unsigned int n_threads = numThreads();
 
      _current_execute_on_flag = EXEC_LINEAR;
 
      // Random interface objects
      for (const auto & it : _random_data_objects)
        it.second->updateSeeds(EXEC_LINEAR);
 
      // This is itself a residual evaluation (distinct from the combined residual/Jacobian path
      // above, which sets this before its own updateMortarMesh() call): mark it so that
      // updateMortarMesh() below knows not to reinit the equation systems mid-evaluation. Reset by
      // resetState() at the bottom of this function.
      setCurrentlyComputingResidual(true);
      if (_displaced_problem)
        _displaced_problem->setCurrentlyComputingResidual(true);
 
      execMultiApps(EXEC_LINEAR);
 
      for (unsigned int tid = 0; tid < n_threads; tid++)
        reinitScalars(tid);
 
      computeUserObjects(EXEC_LINEAR, Moose::PRE_AUX);
 
      _aux->residualSetup();
 
      if (_displaced_problem)
      {
        computeSystems(EXEC_PRE_DISPLACE);
        _displaced_problem->updateMesh();
        if (_mortar_data->hasDisplacedObjects())
          updateMortarMesh();
      }
 
      for (THREAD_ID tid = 0; tid < n_threads; tid++)
      {
        _all_materials.residualSetup(tid);
        _functions.residualSetup(tid);
      }
 
#ifdef MOOSE_KOKKOS_ENABLED
      _kokkos_functions.residualSetup();
#endif
 
      computeSystems(EXEC_LINEAR);
 
      computeUserObjects(EXEC_LINEAR, Moose::POST_AUX);
 
      executeControls(EXEC_LINEAR);
 
      _app.getOutputWarehouse().residualSetup();
 
      _safe_access_tagged_vectors = false;
      _current_nl_sys->computeResidualTags(tags);
    }
    catch (...)
    {
      handleException("computeResidualTags");
    }
  }
  catch (const MooseException &)
  {
    // The buck stops here, we have already handled the exception by
    // calling the system's stopSolve() method, it is now up to PETSc to return a
    // "diverged" reason during the next solve.
  }
  catch (...)
  {
    mooseError("Unexpected exception type");
  }
 
  resetState();
}

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

◆ computeResidualType()

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

virtual

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

Definition at line 8018 of file FEProblemBase.C.

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

◆ computeSystems()

void FEProblemBase::computeSystems ( const ExecFlagType & type )

protected

Do generic system computations.

Definition at line 10392 of file FEProblemBase.C.

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

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

◆ computeTransposeNullSpace()

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

virtual

Definition at line 8577 of file FEProblemBase.C.

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

Referenced by Moose::compute_transpose_nullspace().

◆ computeUserObjectByName()

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

virtual

Compute an user object with the given name.

Definition at line 5416 of file FEProblemBase.C.

{
  const auto old_exec_flag = _current_execute_on_flag;
  _current_execute_on_flag = type;
 
  std::set<int> execution_groups;
 
#ifdef MOOSE_KOKKOS_ENABLED
  TheWarehouse::Query kokkos_query =
      getUOQuery("KokkosUserObject", type, group).condition<AttribName>(name);
  getUOExecutionGroups(kokkos_query, execution_groups);
#endif
 
  TheWarehouse::Query query = getUOQuery("UserObject", type, group).condition<AttribName>(name);
  getUOExecutionGroups(query, execution_groups);
 
  for (const auto execution_group : execution_groups)
  {
#ifdef MOOSE_KOKKOS_ENABLED
    computeKokkosUserObjectsInternal(
        type, kokkos_query.clone().condition<AttribExecutionOrderGroup>(execution_group));
#endif
 
    computeUserObjectsInternal(type,
                               query.clone().condition<AttribExecutionOrderGroup>(execution_group));
  }
 
  _current_execute_on_flag = old_exec_flag;
}

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

◆ computeUserObjects()

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

virtual

Call compute methods on UserObjects.

Definition at line 5449 of file FEProblemBase.C.

{
  std::set<int> execution_groups;
 
#ifdef MOOSE_KOKKOS_ENABLED
  TheWarehouse::Query kokkos_query = getUOQuery("KokkosUserObject", type, group);
  getUOExecutionGroups(kokkos_query, execution_groups);
#endif
 
  TheWarehouse::Query query = getUOQuery("UserObject", type, group);
  getUOExecutionGroups(query, execution_groups);
 
  for (const auto execution_group : execution_groups)
  {
#ifdef MOOSE_KOKKOS_ENABLED
    computeKokkosUserObjectsInternal(
        type, kokkos_query.clone().condition<AttribExecutionOrderGroup>(execution_group));
#endif
 
    computeUserObjectsInternal(type,
                               query.clone().condition<AttribExecutionOrderGroup>(execution_group));
  }
 
  // Exceptions raised on solver execution flags are communicated and handled by the PARALLEL_CATCH
  // surrounding the assembly loops of the residual, Jacobian and linear systems. On all other
  // execution flags there is no solve left to fail, so the exception is communicated here in order
  // to report it at the point of the simulation where it was raised
  if (!Moose::isSolverExecFlag(_current_execute_on_flag))
    checkExceptionAndStopSolve();
}

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

◆ computeUserObjectsInternal()

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

protected

Definition at line 5481 of file FEProblemBase.C.

{
  try
  {
    TIME_SECTION("computeUserObjects", 1, "Computing User Objects");
 
    std::vector<GeneralUserObject *> genobjs;
    query.clone().condition<AttribInterfaces>(Interfaces::GeneralUserObject).queryInto(genobjs);
 
    std::vector<UserObject *> userobjs;
    query.clone()
        .condition<AttribInterfaces>(Interfaces::ElementUserObject | Interfaces::SideUserObject |
                                     Interfaces::InternalSideUserObject |
                                     Interfaces::InterfaceUserObject | Interfaces::DomainUserObject)
        .queryInto(userobjs);
 
    std::vector<UserObject *> tgobjs;
    query.clone()
        .condition<AttribInterfaces>(Interfaces::ThreadedGeneralUserObject)
        .queryInto(tgobjs);
 
    std::vector<UserObject *> nodal;
    query.clone().condition<AttribInterfaces>(Interfaces::NodalUserObject).queryInto(nodal);
 
    std::vector<MortarUserObject *> mortar;
    query.clone().condition<AttribInterfaces>(Interfaces::MortarUserObject).queryInto(mortar);
 
    if (userobjs.empty() && genobjs.empty() && tgobjs.empty() && nodal.empty() && mortar.empty())
      return;
 
    // Start the timer here since we have at least one active user object
    std::string compute_uo_tag = "computeUserObjects(" + Moose::stringify(type) + ")";
 
    // Perform Residual/Jacobian setups
    if (type == EXEC_LINEAR)
    {
      for (auto obj : userobjs)
        obj->residualSetup();
      for (auto obj : nodal)
        obj->residualSetup();
      for (auto obj : mortar)
        obj->residualSetup();
      for (auto obj : tgobjs)
        obj->residualSetup();
      for (auto obj : genobjs)
        obj->residualSetup();
    }
    else if (type == EXEC_NONLINEAR)
    {
      for (auto obj : userobjs)
        obj->jacobianSetup();
      for (auto obj : nodal)
        obj->jacobianSetup();
      for (auto obj : mortar)
        obj->jacobianSetup();
      for (auto obj : tgobjs)
        obj->jacobianSetup();
      for (auto obj : genobjs)
        obj->jacobianSetup();
    }
 
    for (auto obj : userobjs)
      obj->initialize();
 
    // Execute Side/InternalSide/Interface/Elemental/DomainUserObjects
    if (!userobjs.empty())
    {
      // non-nodal user objects have to be run separately before the nodal user objects run
      // because some nodal user objects (NodalNormal related) depend on elemental user objects
      // :-(
      ComputeUserObjectsThread cppt(*this, query);
      Threads::parallel_reduce(getCurrentAlgebraicElementRange(), cppt, numThreads());
 
      // There is one instance in rattlesnake where an elemental user object's finalize depends
      // on a side user object having been finalized first :-(
      joinAndFinalize(query.clone().condition<AttribInterfaces>(Interfaces::SideUserObject));
      joinAndFinalize(
          query.clone().condition<AttribInterfaces>(Interfaces::InternalSideUserObject));
      joinAndFinalize(query.clone().condition<AttribInterfaces>(Interfaces::InterfaceUserObject));
      joinAndFinalize(query.clone().condition<AttribInterfaces>(Interfaces::ElementUserObject));
      joinAndFinalize(query.clone().condition<AttribInterfaces>(Interfaces::DomainUserObject));
    }
 
    // if any elemental user object may have written to variables we need to close the aux solution
    for (const auto & uo : userobjs)
      if (auto euo = dynamic_cast<const ElementUserObject *>(uo);
          euo && euo->hasWritableCoupledVariables())
      {
        _aux->solution().close();
        _aux->system().update();
        break;
      }
 
    // Execute NodalUserObjects
    // BISON has an axial reloc elemental user object that has a finalize func that depends on a
    // nodal user object's prev value. So we can't initialize this until after elemental objects
    // have been finalized :-(
    for (auto obj : nodal)
      obj->initialize();
    if (query.clone().condition<AttribInterfaces>(Interfaces::NodalUserObject).count() > 0)
    {
      ComputeNodalUserObjectsThread cnppt(*this, query);
      Threads::parallel_reduce(getCurrentAlgebraicNodeRange(), cnppt, numThreads());
      joinAndFinalize(query.clone().condition<AttribInterfaces>(Interfaces::NodalUserObject));
    }
 
    // if any nodal user object may have written to variables we need to close the aux solution
    for (const auto & uo : nodal)
      if (auto nuo = dynamic_cast<const NodalUserObject *>(uo);
          nuo && nuo->hasWritableCoupledVariables())
      {
        _aux->solution().close();
        _aux->system().update();
        break;
      }
 
    // Execute MortarUserObjects
    {
      for (auto obj : mortar)
        obj->initialize();
      if (!mortar.empty())
      {
        auto create_and_run_mortar_functors = [this, type, &mortar](const bool displaced)
        {
          // go over mortar interfaces and construct functors
          const auto & mortar_interfaces = getMortarInterfaces(displaced);
          for (const auto & [primary_secondary_boundary_pair, interface_config] : mortar_interfaces)
          {
            auto mortar_uos_to_execute =
                getMortarUserObjects(primary_secondary_boundary_pair.first,
                                     primary_secondary_boundary_pair.second,
                                     displaced,
                                     mortar);
 
            auto * const subproblem = displaced ? cast_ptr<SubProblem *>(_displaced_problem.get())
                                                : cast_ptr<SubProblem *>(this);
            MortarUserObjectThread muot(mortar_uos_to_execute,
                                        *interface_config.amg,
                                        *subproblem,
                                        *this,
                                        displaced,
                                        subproblem->assembly(0, 0));
 
            muot();
          }
        };
 
        create_and_run_mortar_functors(false);
        if (_displaced_problem)
          create_and_run_mortar_functors(true);
      }
      for (auto obj : mortar)
        obj->finalize();
    }
 
    // Execute threaded general user objects
    for (auto obj : tgobjs)
      obj->initialize();
    std::vector<GeneralUserObject *> tguos_zero;
    query.clone()
        .condition<AttribThread>(0)
        .condition<AttribInterfaces>(Interfaces::ThreadedGeneralUserObject)
        .queryInto(tguos_zero);
    for (auto obj : tguos_zero)
    {
      std::vector<GeneralUserObject *> tguos;
      auto q = query.clone()
                   .condition<AttribName>(obj->name())
                   .condition<AttribInterfaces>(Interfaces::ThreadedGeneralUserObject);
      q.queryInto(tguos);
 
      ComputeThreadedGeneralUserObjectsThread ctguot(*this);
 
      // Force one thread per ThreadedGeneralUserObject via grainsize
      Threads::parallel_reduce(GeneralUserObjectRange(tguos.begin(),
                                                      tguos.end(),
                                                      /*grainsize=*/1),
                               ctguot,
                               numThreads());
      joinAndFinalize(q);
    }
 
    // Execute general user objects
    joinAndFinalize(query.clone().condition<AttribInterfaces>(Interfaces::GeneralUserObject), true);
  }
  catch (...)
  {
    handleException("computeUserObjectsInternal");
  }
}

Referenced by computeUserObjectByName(), and computeUserObjects().

◆ computingNonlinearResid() [1/3]

bool SubProblem::computingNonlinearResid ( ) const

inline

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

Definition at line 718 of file SubProblem.h.

718{ return _computing_nonlinear_residual; }

SubProblem::_computing_nonlinear_residual

bool _computing_nonlinear_residual

Whether the non-linear residual is being evaluated.

Definition SubProblem.h:1103

◆ computingNonlinearResid() [2/3]

void FEProblemBase::computingNonlinearResid ( bool computing_nonlinear_residual )

finalvirtual

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

Reimplemented from SubProblem.

Definition at line 10023 of file FEProblemBase.C.

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

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

◆ computingNonlinearResid() [3/3]

virtual void SubProblem::computingNonlinearResid ( const bool computing_nonlinear_residual )

inlinevirtual

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

Reimplemented from SubProblem.

Definition at line 723 of file SubProblem.h.

  {
    _computing_nonlinear_residual = computing_nonlinear_residual;
  }

◆ computingPreSMOResidual()

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

overridevirtual

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

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

Implements SubProblem.

Definition at line 7470 of file FEProblemBase.C.

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

Referenced by DisplacedProblem::computingPreSMOResidual().

◆ computingScalingJacobian() [1/2]

bool FEProblemBase::computingScalingJacobian ( ) const

inlinefinaloverridevirtual

Getter for whether we're computing the scaling jacobian.

Implements SubProblem.

Definition at line 2913 of file FEProblemBase.h.

2913{ return _computing_scaling_jacobian; }

FEProblemBase::_computing_scaling_jacobian

bool _computing_scaling_jacobian

Flag used to indicate whether we are computing the scaling Jacobian.

Definition FEProblemBase.h:3720

◆ computingScalingJacobian() [2/2]

void FEProblemBase::computingScalingJacobian ( bool computing_scaling_jacobian )

inline

Setter for whether we're computing the scaling jacobian.

Definition at line 2908 of file FEProblemBase.h.

  {
    _computing_scaling_jacobian = computing_scaling_jacobian;
  }

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

◆ computingScalingResidual() [1/2]

bool FEProblemBase::computingScalingResidual ( ) const

inlinefinaloverridevirtual

Returns: whether we are currently computing a residual for automatic scaling purposes

Implements SubProblem.

Definition at line 2926 of file FEProblemBase.h.

2926{ return _computing_scaling_residual; }

FEProblemBase::_computing_scaling_residual

bool _computing_scaling_residual

Flag used to indicate whether we are computing the scaling Residual.

Definition FEProblemBase.h:3723

◆ computingScalingResidual() [2/2]

void FEProblemBase::computingScalingResidual ( bool computing_scaling_residual )

inline

Setter for whether we're computing the scaling residual.

Definition at line 2918 of file FEProblemBase.h.

  {
    _computing_scaling_residual = computing_scaling_residual;
  }

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

◆ connectControllableParams()

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

inherited

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

Parameters

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

Definition at line 77 of file MooseBase.C.

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

◆ console()

const ConsoleStream & Problem::console ( ) const

inlineinherited

Return console handle.

Definition at line 48 of file Problem.h.

48{ return _console; }

◆ constJacobian()

bool FEProblemBase::constJacobian ( ) const

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

Definition at line 9865 of file FEProblemBase.C.

{
  return _const_jacobian;
}

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

◆ converged()

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

inlinevirtualinherited

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

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

Definition at line 116 of file SubProblem.h.

116{ return solverSystemConverged(sys_num); }

SubProblem::solverSystemConverged

virtual bool solverSystemConverged(const unsigned int sys_num)

Definition SubProblem.h:103

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

◆ coordTransform()

MooseAppCoordTransform & FEProblemBase::coordTransform ( )

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

Definition at line 10263 of file FEProblemBase.C.

{
  return mesh().coordTransform();
}

◆ copySolutionsBackwards()

void FEProblemBase::copySolutionsBackwards ( )

virtual

Definition at line 7476 of file FEProblemBase.C.

{
  TIME_SECTION("copySolutionsBackwards", 3, "Copying Solutions Backward");
 
  for (auto & sys : _solver_systems)
    sys->copyStateHistoryBackwards();
  _aux->copyStateHistoryBackwards();
}

◆ coupling()

Moose::CouplingType FEProblemBase::coupling ( ) const

inline

Definition at line 197 of file FEProblemBase.h.

197{ return _coupling; }

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

◆ couplingEntries()

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

Definition at line 7029 of file FEProblemBase.C.

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

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

◆ couplingMatrix()

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

inlineoverridevirtual

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

Implements SubProblem.

Definition at line 3938 of file FEProblemBase.h.

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

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

◆ createMortarInterface()

void FEProblemBase::createMortarInterface	(	const std::pair< BoundaryID, BoundaryID > &	primary_secondary_boundary_pair,
		const std::pair< SubdomainID, SubdomainID > &	primary_secondary_subdomain_pair,
		bool	on_displaced,
		bool	periodic,
		const bool	debug,
		const bool	correct_edge_dropping,
		const Real	minimum_projection_angle,
		const Mortar3DSubpatchPlane	mortar_3d_subpatch_plane,
		const MooseEnum &	triangulation,
		const bool	triangulate_triangles,
		const Mortar3DQuadraturePointMapping	mortar_3d_qp_mapping = `Mortar3DQuadraturePointMapping::NORMAL_PROJECTION`
	)

Definition at line 8761 of file FEProblemBase.C.

{
  _has_mortar = true;
 
  if (on_displaced)
    return _mortar_data->createMortarInterface(primary_secondary_boundary_pair,
                                               primary_secondary_subdomain_pair,
                                               *_displaced_problem,
                                               on_displaced,
                                               periodic,
                                               debug,
                                               correct_edge_dropping,
                                               minimum_projection_angle,
                                               mortar_3d_subpatch_plane,
                                               triangulation,
                                               triangulate_triangles,
                                               mortar_3d_qp_mapping);
  else
    return _mortar_data->createMortarInterface(primary_secondary_boundary_pair,
                                               primary_secondary_subdomain_pair,
                                               *this,
                                               on_displaced,
                                               periodic,
                                               debug,
                                               correct_edge_dropping,
                                               minimum_projection_angle,
                                               mortar_3d_subpatch_plane,
                                               triangulation,
                                               triangulate_triangles,
                                               mortar_3d_qp_mapping);
}

◆ createQRules()

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

virtual

Definition at line 6891 of file FEProblemBase.C.

{
  if (order == INVALID_ORDER)
  {
    // automatically determine the integration order
    order = _solver_systems[0]->getMinQuadratureOrder();
    for (const auto i : make_range(std::size_t(1), _solver_systems.size()))
      if (order < _solver_systems[i]->getMinQuadratureOrder())
        order = _solver_systems[i]->getMinQuadratureOrder();
    if (order < _aux->getMinQuadratureOrder())
      order = _aux->getMinQuadratureOrder();
  }
 
  if (volume_order == INVALID_ORDER)
    volume_order = order;
 
  if (face_order == INVALID_ORDER)
    face_order = order;
 
  for (unsigned int tid = 0; tid < numThreads(); ++tid)
    for (const auto i : index_range(_solver_systems))
      _assembly[tid][i]->createQRules(
          type, order, volume_order, face_order, block, allow_negative_qweights);
 
  if (_displaced_problem)
    _displaced_problem->createQRules(
        type, order, volume_order, face_order, block, allow_negative_qweights);
 
  updateMaxQps();
}

Referenced by ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), and createQRules().

◆ createTagMatrices()

void FEProblemBase::createTagMatrices ( CreateTaggedMatrixKey )

Definition at line 762 of file FEProblemBase.C.

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

◆ createTagSolutions()

void FEProblemBase::createTagSolutions ( )

protected

Create extra tagged solution vectors.

Definition at line 778 of file FEProblemBase.C.

{
  for (auto & vector : getParam<std::vector<TagName>>("extra_tag_solutions"))
  {
    auto tag = addVectorTag(vector, Moose::VECTOR_TAG_SOLUTION);
    for (auto & sys : _solver_systems)
      sys->addVector(tag, false, libMesh::GHOSTED);
    _aux->addVector(tag, false, libMesh::GHOSTED);
  }
 
  if (_previous_nl_solution_required)
  {
    // We'll populate the zeroth state of the nonlinear iterations with the current solution for
    // ease of use in doing things like copying solutions backwards. We're just storing pointers in
    // the solution states containers so populating the zeroth state does not cost us the memory of
    // a new vector
    needSolutionState(1, Moose::SolutionIterationType::Nonlinear);
  }
 
  auto tag = addVectorTag(Moose::SOLUTION_TAG, Moose::VECTOR_TAG_SOLUTION);
  for (auto & sys : _solver_systems)
    sys->associateVectorToTag(*sys->system().current_local_solution.get(), tag);
  _aux->associateVectorToTag(*_aux->system().current_local_solution.get(), tag);
}

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

◆ createTagVectors()

void FEProblemBase::createTagVectors ( )

protected

Create extra tagged vectors and matrices.

Definition at line 740 of file FEProblemBase.C.

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

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

◆ currentLinearSysNum()

unsigned int FEProblemBase::currentLinearSysNum ( ) const

overridevirtual

Returns: the current linear system number

Implements SubProblem.

Definition at line 10280 of file FEProblemBase.C.

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

Referenced by DisplacedProblem::currentLinearSysNum().

◆ currentLinearSystem() [1/2]

LinearSystem & FEProblemBase::currentLinearSystem ( )

inline

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

Definition at line 3906 of file FEProblemBase.h.

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

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

◆ currentLinearSystem() [2/2]

const LinearSystem & FEProblemBase::currentLinearSystem ( ) const

inline

Get a constant reference to the current linear system.

Definition at line 3913 of file FEProblemBase.h.

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

◆ currentlyComputingJacobian()

const bool & SubProblem::currentlyComputingJacobian ( ) const

inlineinherited

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

Definition at line 695 of file SubProblem.h.

695{ return _currently_computing_jacobian; };

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

◆ currentlyComputingResidual()

const bool & SubProblem::currentlyComputingResidual ( ) const

inline

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

Definition at line 731 of file SubProblem.h.

731{ return _currently_computing_residual; }

SubProblem::_currently_computing_residual

bool _currently_computing_residual

Whether the residual is being evaluated.

Definition SubProblem.h:1106

Referenced by updateMortarMesh().

◆ currentlyComputingResidualAndJacobian()

const bool & SubProblem::currentlyComputingResidualAndJacobian ( ) const

inlineinherited

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

Definition at line 1483 of file SubProblem.h.

{
  return _currently_computing_residual_and_jacobian;
}

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

◆ currentNlSysNum()

unsigned int FEProblemBase::currentNlSysNum ( ) const

overridevirtual

Returns: the current nonlinear system number

Implements SubProblem.

Definition at line 10269 of file FEProblemBase.C.

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

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

◆ currentNonlinearSystem() [1/2]

NonlinearSystemBase & FEProblemBase::currentNonlinearSystem ( )

inline

Definition at line 3876 of file FEProblemBase.h.

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

Referenced by currentNlSysNum(), NonlinearSystemBase::jacobianSetup(), DefaultNonlinearConvergence::nonlinearSystem(), VariableResidualNormsDebugOutput::output(), Moose::PetscSupport::petscNonlinearConverged(), NonlinearSystemBase::residualSetup(), DefaultNonlinearConvergence::setNonlinearSystemParameters(), and PetscOutput::solveSetup().

◆ currentNonlinearSystem() [2/2]

const NonlinearSystemBase & FEProblemBase::currentNonlinearSystem ( ) const

inline

Definition at line 3883 of file FEProblemBase.h.

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

◆ currentResidualVectorTags()

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

inlineoverridevirtual

Return the residual vector tags we are currently computing.

Implements SubProblem.

Definition at line 3954 of file FEProblemBase.h.

{
  return _current_residual_vector_tags;
}

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

◆ customSetup()

void FEProblemBase::customSetup ( const ExecFlagType & exec_type )

overridevirtual

Reimplemented from SubProblem.

Definition at line 5181 of file FEProblemBase.C.

{
  SubProblem::customSetup(exec_type);
 
  if (_line_search)
    _line_search->customSetup(exec_type);
 
  unsigned int n_threads = numThreads();
  for (THREAD_ID tid = 0; tid < n_threads; tid++)
  {
    _all_materials.customSetup(exec_type, tid);
    _functions.customSetup(exec_type, tid);
  }
 
#ifdef MOOSE_KOKKOS_ENABLED
  _kokkos_functions.customSetup(exec_type);
#endif
 
  _aux->customSetup(exec_type);
  for (auto & nl : _nl)
    nl->customSetup(exec_type);
 
  if (_displaced_problem)
    _displaced_problem->customSetup(exec_type);
 
  for (THREAD_ID tid = 0; tid < n_threads; tid++)
  {
    _internal_side_indicators.customSetup(exec_type, tid);
    _indicators.customSetup(exec_type, tid);
    _markers.customSetup(exec_type, tid);
  }
 
  std::vector<UserObject *> userobjs;
  theWarehouse().query().condition<AttribSystem>("UserObject").queryIntoUnsorted(userobjs);
  for (auto obj : userobjs)
    obj->customSetup(exec_type);
 
#ifdef MOOSE_KOKKOS_ENABLED
  {
    std::vector<UserObjectBase *> userobjs;
    theWarehouse().query().condition<AttribSystem>("KokkosUserObject").queryIntoUnsorted(userobjs);
    for (auto obj : userobjs)
      obj->customSetup(exec_type);
  }
#endif
 
  _app.getOutputWarehouse().customSetup(exec_type);
}

Referenced by execute().

◆ declareManagedRestartableDataWithContext()

template<typename T , typename... Args>

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

protectedinherited

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

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

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

See delcareRestartableData and declareRestartableDataWithContext for more information.

Definition at line 283 of file Restartable.h.

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

◆ declareRecoverableData()

template<typename T , typename... Args>

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

protectedinherited

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

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

Note - this data will NOT be restored on Restart!

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

Parameters

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

Definition at line 358 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);
 
  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);
 
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

◆ declareRestartableData()

template<typename T , typename... Args>

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

protectedinherited

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

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

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

Parameters

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

Definition at line 276 of file Restartable.h.

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

◆ declareRestartableDataHelper()

template<typename T , typename... Args>

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

privateinherited

Helper function for declaring restartable data.

We use this function to reduce code duplication when returning const/nonconst references to the data.

Parameters

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

Definition at line 310 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);
 
  // Here we will create the RestartableData even though we may not use this instance.
  // If it's already in use, the App will return a reference to the existing instance and we'll
  // return that one instead. We might refactor this to have the app create the RestartableData
  // at a later date.
  auto data_ptr =
      std::make_unique<RestartableData<T>>(full_name, context, std::forward<Args>(args)...);
  auto & restartable_data_ref = cast_ref<RestartableData<T> &>(
      registerRestartableDataOnApp(std::move(data_ptr), _restartable_tid));
 
  return restartable_data_ref;
}

◆ declareRestartableDataWithContext()

template<typename T , typename... Args>

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

protectedinherited

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

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

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

Parameters

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

Definition at line 301 of file Restartable.h.

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

◆ declareRestartableDataWithObjectName()

template<typename T , typename... Args>

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

protectedinherited

Declare a piece of data as "restartable".

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

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

Parameters

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

Definition at line 330 of file Restartable.h.

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

◆ declareRestartableDataWithObjectNameWithContext()

template<typename T , typename... Args>

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

protectedinherited

Declare a piece of data as "restartable".

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

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

Parameters

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

Definition at line 340 of file Restartable.h.

{
  std::string old_name = _restartable_name;
 
  _restartable_name = object_name;
 
  T & value = declareRestartableDataWithContext<T>(data_name, context, std::forward<Args>(args)...);
 
  _restartable_name = old_name;
 
  return value;
}

◆ defaultGhosting()

bool SubProblem::defaultGhosting ( )

inlineinherited

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

Definition at line 147 of file SubProblem.h.

147{ return _default_ghosting; }

SubProblem::_default_ghosting

bool _default_ghosting

Whether or not to use default libMesh coupling.

Definition SubProblem.h:1091

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

◆ determineSolverSystem()

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

overrideprivatevirtual

Determine what solver system the provided variable name lies in.

Parameters

var_name	The name of the variable we are doing solver system lookups for
error_if_not_found	Whether to error if the variable name isn't found in any of the solver systems

Returns: A pair in which the first member indicates whether the variable was found in the solver systems and the second member indicates the solver system number in which the variable was found (or an invalid unsigned integer if not found)

Implements SubProblem.

Definition at line 3128 of file FEProblemBase.C.

{
  auto map_it = _solver_var_to_sys_num.find(var_name);
  const bool var_in_sys = map_it != _solver_var_to_sys_num.end();
  if (var_in_sys)
    mooseAssert(_solver_systems[map_it->second]->hasVariable(var_name) ||
                    _solver_systems[map_it->second]->hasScalarVariable(var_name),
                "If the variable is in our FEProblem solver system map, then it must be in the "
                "solver system we expect");
  else if (error_if_not_found)
  {
    if (_aux->hasVariable(var_name) || _aux->hasScalarVariable(var_name))
      mooseError("No solver variable named ",
                 var_name,
                 " found. Did you specify an auxiliary variable when you meant to specify a "
                 "solver variable?");
    else
      mooseError("Unknown variable '",
                 var_name,
                 "'. It does not exist in the solver system(s) or auxiliary system");
  }
 
  return std::make_pair(var_in_sys, var_in_sys ? map_it->second : libMesh::invalid_uint);
}

Referenced by addBoundaryCondition(), addConstraint(), addDamper(), addDGKernel(), addDiracKernel(), addHDGKernel(), addInterfaceKernel(), addKernel(), addNodalKernel(), addScalarKernel(), DisplacedProblem::determineSolverSystem(), and getSystem().

◆ diracKernelInfo()

DiracKernelInfo & SubProblem::diracKernelInfo ( )

virtualinherited

Definition at line 740 of file SubProblem.C.

{
  return _dirac_kernel_info;
}

◆ doingPRefinement()

bool SubProblem::doingPRefinement ( ) const

inherited

Returns: whether we're doing p-refinement

Definition at line 1345 of file SubProblem.C.

{
  return mesh().doingPRefinement();
}

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

◆ dt()

virtual Real & FEProblemBase::dt ( ) const

inlinevirtual

Definition at line 584 of file FEProblemBase.h.

584{ return _dt; }

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

◆ dtOld()

virtual Real & FEProblemBase::dtOld ( ) const

inlinevirtual

Definition at line 585 of file FEProblemBase.h.

585{ return _dt_old; }

Referenced by IterationAdaptiveDT::acceptStep().

◆ duplicateVariableCheck()

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

protected

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

Definition at line 2991 of file FEProblemBase.C.

{
  std::set<SubdomainID> subdomainIDs;
  if (active_subdomains->size() == 0)
  {
    const auto subdomains = _mesh.meshSubdomains();
    subdomainIDs.insert(subdomains.begin(), subdomains.end());
  }
  else
    subdomainIDs.insert(active_subdomains->begin(), active_subdomains->end());
 
  for (auto & sys : _solver_systems)
  {
    SystemBase * curr_sys_ptr = sys.get();
    SystemBase * other_sys_ptr = _aux.get();
    std::string error_prefix = "";
    if (is_aux)
    {
      curr_sys_ptr = _aux.get();
      other_sys_ptr = sys.get();
      error_prefix = "aux";
    }
 
    if (other_sys_ptr->hasVariable(var_name))
      mooseError("Cannot have an auxiliary variable and a solver variable with the same name: ",
                 var_name);
 
    if (curr_sys_ptr->hasVariable(var_name))
    {
      const libMesh::Variable & var =
          curr_sys_ptr->system().variable(curr_sys_ptr->system().variable_number(var_name));
 
      // variable type
      if (var.type() != type)
        mooseError("Mismatching types are specified for ",
                   error_prefix,
                   "variable with name '",
                   var_name,
                   "': '",
                   Moose::stringify(var.type()),
                   "' and '",
                   Moose::stringify(type),
                   "'");
 
      // block-restriction
      if (!(active_subdomains->size() == 0 && var.active_subdomains().size() == 0))
      {
        const auto varActiveSubdomains = var.active_subdomains();
        std::set<SubdomainID> varSubdomainIDs;
        if (varActiveSubdomains.size() == 0)
        {
          const auto subdomains = _mesh.meshSubdomains();
          varSubdomainIDs.insert(subdomains.begin(), subdomains.end());
        }
        else
          varSubdomainIDs.insert(varActiveSubdomains.begin(), varActiveSubdomains.end());
 
        // Is subdomainIDs a subset of varSubdomainIDs? With this we allow the case that the newly
        // requested block restriction is only a subset of the existing one.
        const auto isSubset = std::includes(varSubdomainIDs.begin(),
                                            varSubdomainIDs.end(),
                                            subdomainIDs.begin(),
                                            subdomainIDs.end());
 
        if (!isSubset)
        {
          // helper function: make a string from a set of subdomain ids
          const auto stringifySubdomains = [this](std::set<SubdomainID> subdomainIDs)
          {
            std::stringstream s;
            for (auto const i : subdomainIDs)
            {
              // do we need to insert a comma?
              if (s.tellp() != 0)
                s << ", ";
 
              // insert subdomain name and id -or- only the id (if no name is given)
              const auto subdomainName = _mesh.getSubdomainName(i);
              if (subdomainName.empty())
                s << i;
              else
                s << subdomainName << " (" << i << ")";
            }
            return s.str();
          };
 
          const std::string msg = "Mismatching block-restrictions are specified for " +
                                  error_prefix + "variable with name '" + var_name + "': {" +
                                  stringifySubdomains(varSubdomainIDs) + "} and {" +
                                  stringifySubdomains(subdomainIDs) + "}";
 
          mooseError(msg);
        }
      }
 
      return true;
    }
  }
 
  return false;
}

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

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 49 of file MooseObject.h.

49{ return _enabled; }

MooseObject::_enabled

const bool & _enabled

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

Definition MooseObject.h:71

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

◆ errorOnJacobianNonzeroReallocation()

bool FEProblemBase::errorOnJacobianNonzeroReallocation ( ) const

inline

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

Definition at line 2438 of file FEProblemBase.h.

  {
    return _error_on_jacobian_nonzero_reallocation;
  }

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

◆ errorPrefix()

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

inlineinherited

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

Definition at line 264 of file MooseBase.h.

264{ return messagePrefix(); }

◆ es()

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

inlineoverridevirtual

Implements SubProblem.

Definition at line 181 of file FEProblemBase.h.

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

RestartableEquationSystems::es

libMesh::EquationSystems & es()

Definition RestartableEquationSystems.h:130

Restartable::ManagedValue::set

T & set()

Definition Restartable.h:59

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

◆ execMultiApps()

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

Execute the MultiApps associated with the ExecFlagType.

Definition at line 6235 of file FEProblemBase.C.

{
  // Active MultiApps
  const std::vector<MooseSharedPointer<MultiApp>> & multi_apps =
      _multi_apps[exec_on].getActiveObjects();
 
  // Do anything that needs to be done to Apps before transfers
  for (const auto & multi_app : multi_apps)
    multi_app->preTransfer(_dt, _time);
 
  // Execute Transfers _to_ MultiApps
  execMultiAppTransfers(exec_on, MultiAppTransfer::TO_MULTIAPP);
 
  // Execute Transfers _beween_ MultiApps for the multiapps that don't execute on this flag
  // NOTE: there is usually no need to execute a transfer unless the multiapp providing its
  // data also executed. But we need to obey what the user requested for the execution schedule,
  // hence the two executions
  execMultiAppTransfers(exec_on, MultiAppTransfer::BETWEEN_MULTIAPP);
 
  // Order the multiapps based on their execution group
  // Build the ordered multiapp groups
  std::map<unsigned int, std::vector<MooseSharedPointer<MultiApp>>> ordered_multi_apps;
 
  for (const auto & multi_app : multi_apps)
    ordered_multi_apps[multi_app->getParam<unsigned int>("execution_order_group")].push_back(
        multi_app);
 
  // Check that concurrent multiapps will even be used
  if (multi_apps.size() && _num_concurrent_multiapps > 1)
  {
    bool has_concurrent_apps = false;
    for (const auto & [group, multi_app_group] : ordered_multi_apps)
      if (multi_app_group.size() > 1)
        has_concurrent_apps = true;
    if (!has_concurrent_apps)
      paramInfo(
          "num_concurrent_multiapps",
          "Due to the specified multiapp execution groups, or differences in execution schedules, "
          "concurrent multiapps are not actually used on " +
              Moose::stringify(exec_on));
  }
 
  // Execute MultiApps
  if (multi_apps.size())
  {
    TIME_SECTION("execMultiApps", 1, "Executing MultiApps", false);
 
    if (_verbose_multiapps)
      _console << COLOR_CYAN << "\nExecuting MultiApps on " << Moose::stringify(exec_on)
               << COLOR_DEFAULT << std::endl;
 
    bool success = true;
 
    for (const auto & [group_id, multi_app_group] : ordered_multi_apps)
    {
      bool group_success = true;
      if (_verbose_multiapps && ordered_multi_apps.size() > 1)
        _console << COLOR_CYAN << "\nExecuting MultiApps group " << Moose::stringify(group_id)
                 << COLOR_DEFAULT << std::endl;
 
      if (_verbose_multiapps && multi_app_group.size() > 1)
      {
        // Let the user know about concurrent multiapp use (new option: help them set it up)
        _console << COLOR_CYAN << "\nConcurrent MultiApps: " << std::endl;
        for (const auto & multi_app : multi_app_group)
          _console << multi_app->name() << " ";
        _console << COLOR_DEFAULT << std::endl;
      }
 
      // With concurrent multiapps, the multiapps in a group have each been assigned a disjoint
      // subset of the ranks (see partitionConcurrentMultiApps()), so solveStep() does real work
      // only on those ranks and returns early on the others. Looping here therefore lets different
      // ranks advance different multiapps at the same time - the concurrency comes from the rank
      // partition. This notably avoids racing PETSc's process-global state (communicator and
      // options database).
      for (const auto & multi_app : multi_app_group)
        if (!multi_app->solveStep(_dt, _time, auto_advance))
          group_success = false;
 
      // Whether to move on to the next group must be a collective decision so that every rank
      // leaves the group loop together and stays aligned for the following collectives.
      _communicator.min(group_success);
 
      // No need to solve the other groups if this group failed
      if (!group_success)
      {
        success = false;
        break;
      }
 
      // Execute Transfers _between_ MultiApps after each app executes
      for (const auto & multi_app : multi_app_group)
        execMultiAppTransfers(exec_on, MultiAppTransfer::BETWEEN_MULTIAPP, multi_app->name());
    }
 
    MooseUtils::parallelBarrierNotify(_communicator, _parallel_barrier_messaging);
    _communicator.min(success);
 
    if (!success)
      return false;
 
    if (_verbose_multiapps)
      _console << COLOR_CYAN << "Finished Executing MultiApps on " << Moose::stringify(exec_on)
               << "\n"
               << COLOR_DEFAULT << std::endl;
  }
 
  // Execute Transfers _from_ MultiApps (to the parent app)
  execMultiAppTransfers(exec_on, MultiAppTransfer::FROM_MULTIAPP);
 
  // If we made it here then everything passed
  return true;
}

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

◆ execMultiAppTransfers()

void FEProblemBase::execMultiAppTransfers	(	ExecFlagType	type,
		Transfer::DIRECTION	direction,
		const MultiAppName &	source_app = `""`
	)

Execute MultiAppTransfers associated with execution flag and direction.

Parameters

type	The execution flag to execute.
direction	The direction (to or from) to transfer.
source_app	The source application to execute transfers from. Defaults to all sources

Definition at line 5988 of file FEProblemBase.C.

{
  // Keep track of whether a transfer is actually executed to avoid extraneous console output
  bool is_executing_a_transfer = false;
  bool to_multiapp = direction == MultiAppTransfer::TO_MULTIAPP;
  bool from_multiapp = direction == MultiAppTransfer::FROM_MULTIAPP;
 
  // Build console output
  std::string string_direction;
  std::string additional_source_info = "";
  if (to_multiapp)
    string_direction = " To ";
  else if (from_multiapp)
    string_direction = " From ";
  else
    string_direction = " Between ";
  if (!source_app.empty())
    additional_source_info = " from app '" + source_app + "'";
 
  // This lambda only checks the source app, since the exec_type selection is done in the warehouse
  auto executeThisTransfer = [this, &direction, &source_app, &type](auto & transfer)
  {
    mooseAssert(transfer->getExecuteOnEnum().contains(type), "Should execute on this schedule");
    // no restriction / ordering groups on transfers from parent to child at this time
    if (direction != MultiAppTransfer::BETWEEN_MULTIAPP)
      return true;
    // on sibling transfers, we can delay until the app has been executed if the transfer is set
    // that way.
    if (transfer->getFromName() == source_app && transfer->executeAfterSiblingSourceApp())
    {
      libmesh_ignore(this);
      mooseAssert(this->getMultiApp(transfer->getFromName())->getExecuteOnEnum().contains(type),
                  "from_multiapp should also execute on this schedule");
    }
    // Execute if:
    // - transfer is set execute before from_multiapp, and we are calling this before source apps
    // - from_multiapp app is not executing on this execute_on
    // - from_multiapp just executed (set to source app)
    if ((source_app.empty() && (!transfer->executeAfterSiblingSourceApp() ||
                                !transfer->getFromMultiApp()->getExecuteOnEnum().contains(type))) ||
        (transfer->getFromName() == source_app && transfer->executeAfterSiblingSourceApp()))
      return true;
    return false;
  };
 
  const MooseObjectWarehouse<Transfer> & wh = to_multiapp     ? _to_multi_app_transfers[type]
                                              : from_multiapp ? _from_multi_app_transfers[type]
                                                              : _between_multi_app_transfers[type];
 
  if (wh.hasActiveObjects())
  {
    TIME_SECTION("execMultiAppTransfers", 1, "Executing Transfers");
 
    const auto & transfers = wh.getActiveObjects();
 
    if (_verbose_multiapps)
    {
      VariadicTable<std::string, std::string, std::string, std::string> table(
          {"Name", "Type", "From", "To"});
 
      // Build Table of Transfer Info
      for (const auto & transfer : transfers)
      {
        auto multiapp_transfer = dynamic_cast<MultiAppTransfer *>(transfer.get());
 
        // Don't add transfer to table if it won't execute
        if (!executeThisTransfer(multiapp_transfer))
          continue;
 
        is_executing_a_transfer = true;
        table.addRow(multiapp_transfer->name(),
                     multiapp_transfer->type(),
                     multiapp_transfer->getFromName(),
                     multiapp_transfer->getToName());
      }
 
      // Print it
      if (is_executing_a_transfer)
      {
        _console << COLOR_CYAN << "\nTransfers on " << Moose::stringify(type) << string_direction
                 << "MultiApps" << additional_source_info << COLOR_DEFAULT << ":" << std::endl;
 
        table.print(_console);
      }
    }
 
    for (const auto & transfer : transfers)
    {
      auto multiapp_transfer = libMesh::cast_ptr<MultiAppTransfer *>(transfer.get());
      if (!executeThisTransfer(multiapp_transfer))
        continue;
 
      transfer->setCurrentDirection(direction);
      transfer->execute();
    }
 
    MooseUtils::parallelBarrierNotify(_communicator, _parallel_barrier_messaging);
 
    if (_verbose_multiapps && is_executing_a_transfer)
      _console << COLOR_CYAN << "Transfers on " << Moose::stringify(type) << " Are Finished\n"
               << COLOR_DEFAULT << std::endl;
  }
 
  if (_multi_apps[type].getActiveObjects().size() && !is_executing_a_transfer && _verbose_multiapps)
    _console << COLOR_CYAN << "\nNo Transfers on " << Moose::stringify(type) << string_direction
             << "MultiApps\n"
             << COLOR_DEFAULT << std::endl;
}

Referenced by execMultiApps().

◆ execute()

void FEProblemBase::execute ( const ExecFlagType & exec_type )

virtual

Convenience function for performing execution of MOOSE systems.

Reimplemented in DumpObjectsProblem, MFEMProblem, and EigenProblem.

Definition at line 5231 of file FEProblemBase.C.

{
  // Set the current flag
  setCurrentExecuteOnFlag(exec_type);
 
  if (exec_type != EXEC_INITIAL)
    executeControls(exec_type);
 
  // intentially call this after executing controls because the setups may rely on the controls
  // FIXME: we skip the following flags because they have dedicated setup functions in
  //        SetupInterface and it may not be appropriate to call them here.
  if (!(exec_type == EXEC_INITIAL || exec_type == EXEC_TIMESTEP_BEGIN ||
        exec_type == EXEC_SUBDOMAIN || exec_type == EXEC_NONLINEAR || exec_type == EXEC_LINEAR))
    customSetup(exec_type);
 
  executeSamplers(exec_type);
 
  // Pre-aux UserObjects
  computeUserObjects(exec_type, Moose::PRE_AUX);
 
  // Systems (includes system time derivative and aux kernel calculations)
  computeSystems(exec_type);
  // With the auxiliary system solution computed, sync the displaced problem auxiliary solution
  // before computation of post-aux user objects. The undisplaced auxiliary system current local
  // solution is updated (via System::update) within the AuxiliarySystem class's variable
  // computation methods (e.g. computeElementalVarsHelper, computeNodalVarsHelper), so it is safe to
  // use it here
  if (_displaced_problem)
    _displaced_problem->syncAuxSolution(*getAuxiliarySystem().currentSolution());
 
  // Post-aux UserObjects
  computeUserObjects(exec_type, Moose::POST_AUX);
 
  // Return the current flag to None
  setCurrentExecuteOnFlag(EXEC_NONE);
 
  if (_uo_aux_state_check && !_checking_uo_aux_state)
  {
    // we will only check aux variables and postprocessors
    // checking more reporter data can be added in the future if needed
    std::unique_ptr<NumericVector<Number>> x = _aux->currentSolution()->clone();
    DenseVector<Real> pp_values = getReporterData().getAllRealReporterValues();
 
    // call THIS execute one more time for checking the possible states
    _checking_uo_aux_state = true;
    FEProblemBase::execute(exec_type);
    _checking_uo_aux_state = false;
 
    const Real check_tol = 1e-8;
 
    const Real xnorm = x->l2_norm();
    *x -= *_aux->currentSolution();
    if (x->l2_norm() > check_tol * xnorm)
    {
      const auto & sys = _aux->system();
      const unsigned int n_vars = sys.n_vars();
      std::multimap<Real, std::string, std::greater<Real>> ordered_map;
      for (const auto i : make_range(n_vars))
      {
        const Real vnorm = sys.calculate_norm(*x, i, DISCRETE_L2);
        ordered_map.emplace(vnorm, sys.variable_name(i));
      }
 
      std::ostringstream oss;
      for (const auto & [error_norm, var_name] : ordered_map)
        oss << "  {" << var_name << ", " << error_norm << "},\n";
 
      mooseError("Aux kernels, user objects appear to have states for aux variables on ",
                 exec_type,
                 ".\nVariable error norms in descending order:\n",
                 oss.str());
    }
 
    const DenseVector<Real> new_pp_values = getReporterData().getAllRealReporterValues();
    if (pp_values.size() != new_pp_values.size())
      mooseError("Second execution for uo/aux state check should not change the number of "
                 "real reporter values");
 
    const Real ppnorm = pp_values.l2_norm();
    pp_values -= new_pp_values;
    if (pp_values.l2_norm() > check_tol * ppnorm)
    {
      const auto pp_names = getReporterData().getAllRealReporterFullNames();
      std::multimap<Real, std::string, std::greater<Real>> ordered_map;
      for (const auto i : index_range(pp_names))
        ordered_map.emplace(std::abs(pp_values(i)), pp_names[i]);
 
      std::ostringstream oss;
      for (const auto & [error_norm, pp_name] : ordered_map)
        oss << "  {" << pp_name << ", " << error_norm << "},\n";
 
      mooseError("Aux kernels, user objects appear to have states for real reporter values on ",
                 exec_type,
                 ".\nErrors of real reporter values in descending order:\n",
                 oss.str());
    }
  }
}

Referenced by EigenExecutionerBase::chebyshev(), FixedPointSolve::examineFixedPointConvergence(), SteadyBase::execute(), TransientBase::execute(), execute(), MFEMProblem::execute(), EigenProblem::execute(), EigenExecutionerBase::init(), NonlinearEigen::init(), Steady::init(), TransientBase::init(), EigenExecutionerBase::makeBXConsistent(), EigenExecutionerBase::normalizeSolution(), Moose::PetscSupport::petscLinearConverged(), Moose::PetscSupport::petscNonlinearConverged(), EigenExecutionerBase::postExecute(), FEProblemSolve::solve(), FixedPointSolve::solve(), FixedPointSolve::solveStep(), InversePowerMethod::takeStep(), NonlinearEigen::takeStep(), and MFEMTransient::takeStep().

◆ executeAllObjects()

void FEProblemBase::executeAllObjects ( const ExecFlagType & exec_type )

virtual

Definition at line 5176 of file FEProblemBase.C.

5177{

5178}

Referenced by Executor::exec().

◆ executeControls()

void FEProblemBase::executeControls ( const ExecFlagType & exec_type )

Performs setup and execute calls for Control objects.

Definition at line 5673 of file FEProblemBase.C.

{
  if (_control_warehouse[exec_type].hasActiveObjects())
  {
    TIME_SECTION("executeControls", 1, "Executing Controls");
 
    DependencyResolver<std::shared_ptr<Control>> resolver;
 
    auto controls_wh = _control_warehouse[exec_type];
    // Add all of the dependencies into the resolver and sort them
    for (const auto & it : controls_wh.getActiveObjects())
    {
      // Make sure an item with no dependencies comes out too!
      resolver.addItem(it);
 
      std::vector<std::string> & dependent_controls = it->getDependencies();
      for (const auto & depend_name : dependent_controls)
      {
        if (controls_wh.hasActiveObject(depend_name))
        {
          auto dep_control = controls_wh.getActiveObject(depend_name);
          resolver.addEdge(dep_control, it);
        }
        else
          mooseError("The Control \"",
                     depend_name,
                     "\" was not created, did you make a "
                     "spelling mistake or forget to include it "
                     "in your input file?");
      }
    }
 
    const auto & ordered_controls = resolver.getSortedValues();
 
    if (!ordered_controls.empty())
    {
      // already called by initialSetup when exec_type == EXEC_INITIAL
      if (exec_type != EXEC_INITIAL)
        _control_warehouse.setup(exec_type);
 
      // Run the controls in the proper order
      for (const auto & control : ordered_controls)
        control->execute();
    }
  }
}

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

◆ executeSamplers()

void FEProblemBase::executeSamplers ( const ExecFlagType & exec_type )

Performs setup and execute calls for Sampler objects.

Definition at line 5721 of file FEProblemBase.C.

{
  // TODO: This should be done in a threaded loop, but this should be super quick so for now
  // do a serial loop.
  for (THREAD_ID tid = 0; tid < numThreads(); ++tid)
  {
    std::vector<Sampler *> objects;
    theWarehouse()
        .query()
        .condition<AttribSystem>("Sampler")
        .condition<AttribThread>(tid)
        .condition<AttribExecOns>(exec_type)
        .queryInto(objects);
 
    if (!objects.empty())
    {
      TIME_SECTION("executeSamplers", 1, "Executing Samplers");
      FEProblemBase::objectSetupHelper<Sampler>(objects, exec_type);
      FEProblemBase::objectExecuteHelper<Sampler>(objects);
    }
  }
}

Referenced by execute().

◆ feBackend()

virtual Moose::FEBackend FEProblemBase::feBackend ( ) const

inlinevirtual

Reimplemented in MFEMProblem.

Definition at line 3060 of file FEProblemBase.h.

3060{ return Moose::FEBackend::LibMesh; }

Moose::FEBackend::LibMesh

@ LibMesh

Referenced by ConsoleUtils::outputExecutionInformation(), and ConsoleUtils::outputMeshInformation().

◆ fieldScalarCouplingEntries()

const std::vector< std::pair< MooseVariableFieldBase , MooseVariableScalar > > & FEProblemBase::fieldScalarCouplingEntries	(	const THREAD_ID	tid,
		const unsigned int	nl_sys_num
	)		const

Definition at line 7041 of file FEProblemBase.C.

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

◆ finalizeMultiApps()

void FEProblemBase::finalizeMultiApps ( )

Definition at line 6350 of file FEProblemBase.C.

{
  const auto & multi_apps = _multi_apps.getActiveObjects();
 
  for (const auto & multi_app : multi_apps)
    multi_app->finalize();
}

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

◆ finalNonlinearResidual()

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

overridevirtual

Reimplemented from SubProblem.

Definition at line 7464 of file FEProblemBase.C.

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

◆ finishMultiAppStep()

void FEProblemBase::finishMultiAppStep	(	ExecFlagType	type,
		bool	recurse_through_multiapp_levels = `false`
	)

Finish the MultiApp time step (endStep, postStep) associated with the ExecFlagType.

Optionally recurse through all multi-app levels

Definition at line 6378 of file FEProblemBase.C.

{
  const auto & multi_apps = _multi_apps[type].getActiveObjects();
 
  if (multi_apps.size())
  {
    if (_verbose_multiapps)
      _console << COLOR_CYAN << "\nAdvancing MultiApps on " << type.name() << COLOR_DEFAULT
               << std::endl;
 
    for (const auto & multi_app : multi_apps)
      multi_app->finishStep(recurse_through_multiapp_levels);
 
    MooseUtils::parallelBarrierNotify(_communicator, _parallel_barrier_messaging);
 
    if (_verbose_multiapps)
      _console << COLOR_CYAN << "Finished Advancing MultiApps on " << type.name() << "\n"
               << COLOR_DEFAULT << std::endl;
  }
}

Referenced by advanceMultiApps(), TransientBase::execute(), TransientMultiApp::finishStep(), and TransientBase::incrementStepOrReject().

◆ flagInvalidSolutionInternal()

template<bool warning>

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

protectedinherited

Set solution invalid mark for the given solution ID.

Definition at line 41 of file SolutionInvalidInterface.C.

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

◆ forceOutput()

void FEProblemBase::forceOutput ( )

Indicates that the next call to outputStep should be forced.

This is needed by the MultiApp system, if forceOutput is called the next call to outputStep, regardless of the type supplied to the call, will be executed with EXEC_FORCED.

Forced output will NOT override the allowOutput flag.

Definition at line 7627 of file FEProblemBase.C.

{
  _app.getOutputWarehouse().forceOutput();
}

Referenced by TransientMultiApp::solveStep().

◆ fvBCsIntegrityCheck() [1/2]

bool FEProblemBase::fvBCsIntegrityCheck ( ) const

inline

Returns: whether to perform a boundary condition integrity check for finite volume

Definition at line 2828 of file FEProblemBase.h.

2828{ return _fv_bcs_integrity_check; }

◆ fvBCsIntegrityCheck() [2/2]

void FEProblemBase::fvBCsIntegrityCheck ( bool fv_bcs_integrity_check )

inline

Parameters

fv_bcs_integrity_check Whether to perform a boundary condition integrity check for finite volume

Definition at line 3944 of file FEProblemBase.h.

{
  if (!_fv_bcs_integrity_check)
    // the user has requested that we don't check integrity so we will honor that
    return;
 
  _fv_bcs_integrity_check = fv_bcs_integrity_check;
}

◆ geomSearchData()

virtual GeometricSearchData & FEProblemBase::geomSearchData ( )

inlineoverridevirtual

Implements SubProblem.

Definition at line 2100 of file FEProblemBase.h.

2100{ return _geometric_search_data; }

Referenced by NonlinearSystemBase::augmentSparsity(), NonlinearSystemBase::computeJacobianInternal(), DMMooseGetEmbedding_Private(), and DMSetUp_Moose_Pre().

◆ getActiveElementalMooseVariables()

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

virtualinherited

Get the MOOSE variables to be reinited on each element.

Parameters

tid	The thread id

Definition at line 446 of file SubProblem.C.

{
  return _active_elemental_moose_variables[tid];
}

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

◆ getActiveFEVariableCoupleableMatrixTags()

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

inherited

Definition at line 382 of file SubProblem.C.

{
  return _active_fe_var_coupleable_matrix_tags[tid];
}

◆ getActiveFEVariableCoupleableVectorTags()

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

inherited

Definition at line 388 of file SubProblem.C.

{
  return _active_fe_var_coupleable_vector_tags[tid];
}

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute().

◆ getActiveScalarVariableCoupleableMatrixTags()

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

inherited

Definition at line 423 of file SubProblem.C.

{
  return _active_sc_var_coupleable_matrix_tags[tid];
}

Referenced by MooseVariableScalar::reinit().

◆ getActiveScalarVariableCoupleableVectorTags()

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

inherited

Definition at line 429 of file SubProblem.C.

{
  return _active_sc_var_coupleable_vector_tags[tid];
}

◆ getActualFieldVariable()

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

overridevirtual

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

Implements SubProblem.

Definition at line 6581 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    if (sys->hasVariable(var_name))
      return sys->getActualFieldVariable<Real>(tid, var_name);
  if (_aux->hasVariable(var_name))
    return _aux->getActualFieldVariable<Real>(tid, var_name);
 
  mooseError("Unknown variable " + var_name);
}

Referenced by MultiAppVariableValueSampleTransfer::execute().

◆ getArrayVariable()

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

overridevirtual

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

Implements SubProblem.

Definition at line 6605 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    if (sys->hasVariable(var_name))
      return sys->getFieldVariable<RealEigenVector>(tid, var_name);
  if (_aux->hasVariable(var_name))
    return _aux->getFieldVariable<RealEigenVector>(tid, var_name);
 
  mooseError("Unknown variable " + var_name);
}

Referenced by CoupleableMooseVariableDependencyIntermediateInterface::coupledArrayValueByName(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), and PointwiseRenormalizeVector::PointwiseRenormalizeVector().

◆ getAuxiliarySystem()

AuxiliarySystem & FEProblemBase::getAuxiliarySystem ( )

inline

Definition at line 1094 of file FEProblemBase.h.

1094{ return *_aux; }

Referenced by Adaptivity::adaptMesh(), DisplacedProblem::addTimeIntegrator(), ElementSubdomainModifierBase::applyIC(), TransientMultiApp::appTransferVector(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), PNGOutput::calculateRescalingValues(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCsJacobian(), NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeResidualTags(), NonlinearSystemBase::constraintResiduals(), DisplacedProblem::DisplacedProblem(), EigenExecutionerBase::EigenExecutionerBase(), execute(), ActivateElementsUserObjectBase::initSolutions(), EigenExecutionerBase::inversePowerIteration(), PNGOutput::makeMeshFunc(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), ConsoleUtils::outputAuxiliarySystemInformation(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), MultiApp::restore(), NonlinearSystemBase::setConstraintSecondaryValues(), TransientMultiApp::setupApp(), TransientMultiApp::solveStep(), AB2PredictorCorrector::step(), DisplacedProblem::syncSolutions(), Coupleable::writableCoupledValue(), and MoveNodesByParsedExpressionModifier::writeOutputs().

◆ getAxisymmetricRadialCoord()

unsigned int SubProblem::getAxisymmetricRadialCoord ( ) const

inherited

Returns the desired radial direction for RZ coordinate transformation.

Returns: The coordinate direction for the radial direction

Definition at line 788 of file SubProblem.C.

{
  return mesh().getAxisymmetricRadialCoord();
}

◆ getBase()

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

inlineinherited

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

Definition at line 147 of file MooseBase.h.

147{ return _pars.getBase(); }

Referenced by MooseBase::uniqueParameterName().

◆ getBndMaterialPropertyStorage()

const MaterialPropertyStorage & FEProblemBase::getBndMaterialPropertyStorage ( )

inline

Definition at line 2122 of file FEProblemBase.h.

2122{ return _bnd_material_props; }

◆ getCheckedPointerParam()

template<typename T >

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

inherited

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

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

Definition at line 450 of file MooseBase.h.

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

◆ getConsumedPropertyMap()

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

inherited

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

Definition at line 734 of file SubProblem.C.

{
  return _consumed_material_properties;
}

Referenced by MaterialPropertyDebugOutput::output().

◆ getControlWarehouse()

ExecuteMooseObjectWarehouse< Control > & FEProblemBase::getControlWarehouse ( )

inline

Reference to the control logic warehouse.

Definition at line 2620 of file FEProblemBase.h.

2620{ return _control_warehouse; }

Referenced by LibtorchControlValuePostprocessor::initialSetup(), and LibtorchArtificialNeuralNetParameters::initialSetup().

◆ getConvergence()

Convergence & FEProblemBase::getConvergence	(	const std::string &	name,
		const THREAD_ID	tid = `0`
	)		const

virtual

Gets a Convergence object.

Definition at line 2854 of file FEProblemBase.C.

{
  auto * const ret = dynamic_cast<Convergence *>(_convergences.getActiveObject(name, tid).get());
  if (!ret)
    mooseError("The Convergence object '", name, "' does not exist.");
 
  return *ret;
}

Referenced by TransientBase::convergedToSteadyState(), NonlinearSystemBase::convergence(), FEProblemSolve::convergenceSetup(), FixedPointSolve::examineFixedPointConvergence(), TransientBase::init(), FixedPointIterationAdaptiveDT::init(), ParsedConvergence::initializeConvergenceSymbol(), FixedPointSolve::initialSetup(), SteffensenSolve::initialSetup(), Moose::PetscSupport::petscLinearConverged(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

◆ getConvergenceObjects()

const std::vector< std::shared_ptr< Convergence > > & FEProblemBase::getConvergenceObjects ( const THREAD_ID tid = 0 ) const

virtual

Gets the Convergence objects.

Definition at line 2864 of file FEProblemBase.C.

{
  return _convergences.getActiveObjects(tid);
}

◆ getCoordSystem()

Moose::CoordinateSystemType SubProblem::getCoordSystem ( SubdomainID sid ) const

inherited

Definition at line 1283 of file SubProblem.C.

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

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

◆ getCurrentAlgebraicBndNodeRange()

const ConstBndNodeRange & FEProblemBase::getCurrentAlgebraicBndNodeRange ( )

Definition at line 10421 of file FEProblemBase.C.

{
  if (!_current_algebraic_bnd_node_range)
    return *_mesh.getBoundaryNodeRange();
 
  return *_current_algebraic_bnd_node_range;
}

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeNodalBCsJacobian(), NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), NonlinearSystemBase::computeResidualInternal(), projectSolution(), and NonlinearSystemBase::setInitialSolution().

◆ getCurrentAlgebraicElementRange()

const ConstElemRange & FEProblemBase::getCurrentAlgebraicElementRange ( )

These are the element and nodes that contribute to the jacobian and residual for this local processor.

getCurrentAlgebraicElementRange() returns the element range that contributes to the system getCurrentAlgebraicNodeRange() returns the node range that contributes to the system getCurrentAlgebraicBndNodeRange returns the boundary node ranges that contributes to the system

Definition at line 10405 of file FEProblemBase.C.

{
  if (!_current_algebraic_elem_range)
    return *_mesh.getActiveLocalElementRange();
 
  return *_current_algebraic_elem_range;
}

Referenced by NonlinearSystemBase::computeDamping(), computeIndicators(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), computeMarkers(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeScaling(), computeUserObjectsInternal(), initialSetup(), projectSolution(), and updateMaxQps().

◆ getCurrentAlgebraicNodeRange()

const ConstNodeRange & FEProblemBase::getCurrentAlgebraicNodeRange ( )

Definition at line 10413 of file FEProblemBase.C.

{
  if (!_current_algebraic_node_range)
    return *_mesh.getLocalNodeRange();
 
  return *_current_algebraic_node_range;
}

Referenced by NonlinearSystemBase::computeDamping(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), and computeUserObjectsInternal().

◆ getCurrentExecuteOnFlag()

const ExecFlagType & FEProblemBase::getCurrentExecuteOnFlag ( ) const

Return/set the current execution flag.

Returns EXEC_NONE when not being executed.

See also: FEProblemBase::execute

Definition at line 5164 of file FEProblemBase.C.

{
  return _current_execute_on_flag;
}

◆ getCurrentICState()

unsigned short FEProblemBase::getCurrentICState ( )

Retrieves the current initial condition state.

Returns: current initial condition state

Definition at line 10464 of file FEProblemBase.C.

{
  return _current_ic_state;
}

Referenced by ComputeInitialConditionThread::operator()().

◆ getDataFileName()

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

inherited

Deprecated method.

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

Definition at line 21 of file DataFileInterface.C.

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

◆ getDataFileNameByName()

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

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

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

◆ getDataFilePath()

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

inherited

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

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

Definition at line 40 of file DataFileInterface.C.

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

Referenced by DataFileInterface::getDataFileNameByName().

◆ getDiracElements()

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

overridevirtual

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

Implements SubProblem.

Definition at line 2667 of file FEProblemBase.C.

{
  // First add in the undisplaced elements
  elems = _dirac_kernel_info.getElements();
 
  if (_displaced_problem)
  {
    std::set<const Elem *> displaced_elements;
    _displaced_problem->getDiracElements(displaced_elements);
 
    { // Use the ids from the displaced elements to get the undisplaced elements
      // and add them to the list
      for (const auto & elem : displaced_elements)
        elems.insert(_mesh.elemPtr(elem->id()));
    }
  }
}

Referenced by NonlinearSystemBase::computeDiracContributions().

◆ getDiscreteMaterialWarehouse()

const MaterialWarehouse & FEProblemBase::getDiscreteMaterialWarehouse ( ) const

inline

Definition at line 2378 of file FEProblemBase.h.

2378{ return _discrete_materials; }

◆ getDisplacedProblem() [1/2]

virtual std::shared_ptr< DisplacedProblem > FEProblemBase::getDisplacedProblem ( )

inlinevirtual

Definition at line 2056 of file FEProblemBase.h.

2056{ return _displaced_problem; }

◆ getDisplacedProblem() [2/2]

virtual std::shared_ptr< const DisplacedProblem > FEProblemBase::getDisplacedProblem ( ) const

inlinevirtual

Definition at line 2052 of file FEProblemBase.h.

  {
    return _displaced_problem;
  }

◆ getDistribution()

Distribution & FEProblemBase::getDistribution ( const std::string & name )

virtual

Definition at line 2936 of file FEProblemBase.C.

{
  std::vector<Distribution *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>("Distribution")
      .condition<AttribName>(name)
      .queryInto(objs);
  if (objs.empty())
  {
    mooseAssert(getMooseApp().actionWarehouse().isTaskComplete("add_distribution"),
                "A Distribution getter was called before Distributions have been constructed. "
                "If you are attempting to access this object in the constructor of another object "
                "then make sure that the Distribution is constructed before the object using it.");
    mooseError("Unable to find Distribution with name '" + name + "'");
  }
  return *(objs[0]);
}

Referenced by MooseServer::buildDistPlotResponses(), DistributionInterface::getDistribution(), and DistributionInterface::getDistributionByName().

◆ getEvaluableElementRange()

const ConstElemRange & FEProblemBase::getEvaluableElementRange ( )

In general, {evaluable elements} >= {local elements} U {algebraic ghosting elements}.

That is, the number of evaluable elements does NOT necessarily equal to the number of local and algebraic ghosting elements. For example, if using a Lagrange basis for all variables, if a non-local, non-algebraically-ghosted element is surrounded by neighbors which are local or algebraically ghosted, then all the nodal (Lagrange) degrees of freedom associated with the non-local, non-algebraically-ghosted element will be evaluable, and hence that element will be considered evaluable.

getNonlinearEvaluableElementRange() returns the evaluable element range based on the nonlinear system dofmap; getAuxliaryEvaluableElementRange() returns the evaluable element range based on the auxiliary system dofmap; getEvaluableElementRange() returns the element range that is evaluable based on both the nonlinear dofmap and the auxliary dofmap.

Definition at line 928 of file FEProblemBase.C.

{
  if (!_evaluable_local_elem_range)
  {
    std::vector<const DofMap *> dof_maps(es().n_systems());
    for (const auto i : make_range(es().n_systems()))
    {
      const auto & sys = es().get_system(i);
      dof_maps[i] = &sys.get_dof_map();
    }
    _evaluable_local_elem_range =
        std::make_unique<ConstElemRange>(_mesh.getMesh().multi_evaluable_elements_begin(dof_maps),
                                         _mesh.getMesh().multi_evaluable_elements_end(dof_maps));
  }
  return *_evaluable_local_elem_range;
}

Referenced by NodalPatchRecoveryBase::gatherRequestList().

◆ getExecutor()

virtual Executor & FEProblemBase::getExecutor ( const std::string & name )

inlinevirtual

Definition at line 2510 of file FEProblemBase.h.

2510{ return _app.getExecutor(name); }

MooseApp::getExecutor

Executor * getExecutor() const

Definition MooseApp.h:338

◆ getFailNextNonlinearConvergenceCheck()

bool FEProblemBase::getFailNextNonlinearConvergenceCheck ( ) const

inline

Whether it will skip further residual evaluations and fail the next nonlinear convergence check(s)

Definition at line 2969 of file FEProblemBase.h.

2969{ return getFailNextSystemConvergenceCheck(); }

FEProblemBase::getFailNextSystemConvergenceCheck

bool getFailNextSystemConvergenceCheck() const

Whether it will fail the next system convergence check(s), triggering failed step behavior.

Definition FEProblemBase.h:2971

Referenced by NonlinearSystemBase::computeScaling(), NonlinearSystem::converged(), Moose::PetscSupport::petscNonlinearConverged(), and ComputeResidualFunctor::residual().

◆ getFailNextSystemConvergenceCheck()

bool FEProblemBase::getFailNextSystemConvergenceCheck ( ) const

inline

Whether it will fail the next system convergence check(s), triggering failed step behavior.

Definition at line 2971 of file FEProblemBase.h.

2971{ return _fail_next_system_convergence_check; }

Referenced by getFailNextNonlinearConvergenceCheck(), and Moose::PetscSupport::petscLinearConverged().

◆ getFunction()

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

virtual

Definition at line 2796 of file FEProblemBase.C.

{
  // This thread lock is necessary since this method will create functions
  // for all threads if one is missing.
  Threads::spin_mutex::scoped_lock lock(get_function_mutex);
 
  if (!hasFunction(name, tid))
  {
    // If we didn't find a function, it might be a default function, attempt to construct one now
    std::istringstream ss(name);
    Real real_value;
 
    // First see if it's just a constant. If it is, build a ConstantFunction
    if (ss >> real_value && ss.eof())
    {
      InputParameters params = _factory.getValidParams("ConstantFunction");
      params.set<Real>("value") = real_value;
      addFunction("ConstantFunction", ss.str(), params);
    }
    else
    {
      FunctionParserBase<Real> fp;
      std::string vars = "x,y,z,t,NaN,pi,e";
      if (fp.Parse(name, vars) == -1) // -1 for success
      {
        // It parsed ok, so build a MooseParsedFunction
        InputParameters params = _factory.getValidParams("ParsedFunction");
        params.set<std::string>("expression") = name;
        addFunction("ParsedFunction", name, params);
      }
    }
 
    // Try once more
    if (!hasFunction(name, tid))
    {
      mooseAssert(getMooseApp().actionWarehouse().isTaskComplete("add_function"),
                  "getFunction() was called before Functions have been constructed. The requested "
                  "Function '" +
                      name + "' may exist in the input file, but Functions are not available yet.");
 
      mooseError("Unable to find function " + name);
    }
  }
 
  auto * const ret = dynamic_cast<Function *>(_functions.getActiveObject(name, tid).get());
  if (!ret)
    mooseError("No function named ", name, " of appropriate type");
 
  return *ret;
}

Referenced by MFEMProblem::addFunction(), MooseServer::buildFuncPlotResponse(), FunctionInterface::getFunctionByName(), FunctionPeriodicBoundary::getFunctions(), IterationAdaptiveDT::init(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), and ParsedConvergence::initializeFunctionSymbol().

◆ getFunctionWarehouse()

const MooseObjectWarehouse< Function > & FEProblemBase::getFunctionWarehouse ( )

inline

Definition at line 2367 of file FEProblemBase.h.

2367{ return _functions; }

◆ getFunctor()

template<typename T >

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

inherited

Template Parameters

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

Parameters

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

Returns: a constant reference to the functor

Definition at line 1210 of file SubProblem.h.

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

Referenced by FunctorInterface::getFunctorByName().

◆ getFVAdvectedInterpolationMethod()

const FVAdvectedInterpolationMethod & FEProblemBase::getFVAdvectedInterpolationMethod	(	const InterpolationMethodName &	name,
		const THREAD_ID	tid = `0`
	)		const

Retrieve an advected interpolation method.

Parameters

name	The name of the method.
tid	The thread ID.

Definition at line 4944 of file FEProblemBase.C.

{
  const auto & method = getFVInterpolationMethod(name, tid);
  const auto * advected_method = dynamic_cast<const FVAdvectedInterpolationMethod *>(&method);
 
  if (!advected_method)
    mooseError("FVInterpolationMethod '",
               name,
               "' (",
               method.type(),
               ") is not an advected interpolation method.");
 
  return *advected_method;
}

Referenced by FVInterpolationMethodInterface::getFVAdvectedInterpolationMethod().

◆ getFVFaceInterpolationMethod()

const FVFaceInterpolationMethod & FEProblemBase::getFVFaceInterpolationMethod	(	const InterpolationMethodName &	name,
		const THREAD_ID	tid = `0`
	)		const

Retrieve a scalar face interpolation method.

Parameters

name	The name of the method.
tid	The thread ID.

Definition at line 4927 of file FEProblemBase.C.

{
  const auto & method = getFVInterpolationMethod(name, tid);
  const auto * face_method = dynamic_cast<const FVFaceInterpolationMethod *>(&method);
 
  if (!face_method)
    mooseError("FVInterpolationMethod '",
               name,
               "' (",
               method.type(),
               ") is not a scalar face interpolation method.");
 
  return *face_method;
}

Referenced by FVInterpolationMethodInterface::getFVFaceInterpolationMethod().

◆ getFVGradientMethod() [1/2]

FVGradientMethod & FEProblemBase::getFVGradientMethod	(	const GradientMethodName &	name,
		const THREAD_ID	tid = `0`
	)

Retrieve a writable FV gradient method owned by this problem.

Parameters

name	The name of the method.
tid	The thread ID.

Definition at line 4880 of file FEProblemBase.C.

{
  return const_cast<FVGradientMethod &>(
      static_cast<const FEProblemBase &>(*this).getFVGradientMethod(name, tid));
}

Referenced by getFVGradientMethod().

◆ getFVGradientMethod() [2/2]

const FVGradientMethod & FEProblemBase::getFVGradientMethod	(	const GradientMethodName &	name,
		const THREAD_ID	tid = `0`
	)		const

Retrieve a read-only FV gradient method owned by this problem.

Parameters

name	The name of the method.
tid	The thread ID.

Definition at line 4862 of file FEProblemBase.C.

{
  std::vector<FVGradientMethod *> methods;
  theWarehouse()
      .query()
      .condition<AttribSystem>("FVGradientMethod")
      .condition<AttribThread>(tid)
      .condition<AttribName>(name)
      .queryInto(methods);
 
  if (methods.empty())
    mooseError("Unable to find FVGradientMethod with name '", name, "'");
 
  mooseAssert(methods.size() == 1, "Expected a single FVGradientMethod per thread");
  return *(methods[0]);
}

◆ getFVInitialConditionWarehouse()

const FVInitialConditionWarehouse & FEProblemBase::getFVInitialConditionWarehouse ( ) const

inline

Return FVInitialCondition storage.

Definition at line 2164 of file FEProblemBase.h.

2164{ return _fv_ics; }

Referenced by ComputeFVInitialConditionThread::operator()(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), and ComputeFVInitialConditionThread::printGeneralExecutionInformation().

◆ getFVInterpolationMethod()

const FVInterpolationMethod & FEProblemBase::getFVInterpolationMethod	(	const InterpolationMethodName &	name,
		const THREAD_ID	tid = `0`
	)		const

Retrieve an FV interpolation method.

Parameters

name	The name of the method.
tid	The thread ID.

Definition at line 4900 of file FEProblemBase.C.

{
  std::vector<FVInterpolationMethod *> methods;
  theWarehouse()
      .query()
      .condition<AttribSystem>("FVInterpolationMethod")
      .condition<AttribThread>(tid)
      .condition<AttribName>(name)
      .queryInto(methods);
 
  if (methods.empty())
  {
    mooseAssert(getMooseApp().actionWarehouse().isTaskComplete("add_interpolation_method"),
                "An FVInterpolationMethod getter was called before FVInterpolationMethods have "
                "been constructed. If you are attempting to access this object in the constructor "
                "of another object then make sure that the FVInterpolationMethod is constructed "
                "before the object using it.");
 
    mooseError("Unable to find FVInterpolationMethod with name '", name, "'");
  }
 
  mooseAssert(methods.size() == 1, "Expected a single FVInterpolationMethod per thread");
  return *(methods[0]);
}

Referenced by getFVAdvectedInterpolationMethod(), and getFVFaceInterpolationMethod().

◆ getFVMatsAndDependencies()

void FEProblemBase::getFVMatsAndDependencies	(	SubdomainID	block_id,
		std::vector< std::shared_ptr< MaterialBase > > &	face_materials,
		std::vector< std::shared_ptr< MaterialBase > > &	neighbor_materials,
		std::set< MooseVariableFieldBase * > &	variables,
		const THREAD_ID	tid
	)

Get the materials and variables potentially needed for FV.

Parameters

block_id	SubdomainID The subdomain id that we want to retrieve materials for
face_materials	The face materials container that we will fill
neighbor_materials	The neighbor materials container that we will fill
variables	The variables container that we will fill that our materials depend on
tid	The thread id

Definition at line 10096 of file FEProblemBase.C.

{
  if (_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
  {
    auto & this_face_mats =
        _materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid);
    for (std::shared_ptr<MaterialBase> face_mat : this_face_mats)
      if (face_mat->ghostable())
      {
        face_materials.push_back(face_mat);
        auto & var_deps = face_mat->getMooseVariableDependencies();
        for (auto * var : var_deps)
        {
          if (!var->isFV())
            mooseError(
                "Ghostable materials should only have finite volume variables coupled into them.");
          else if (face_mat->hasStatefulProperties())
            mooseError("Finite volume materials do not currently support stateful properties.");
          variables.insert(var);
        }
      }
  }
 
  if (_materials[Moose::NEIGHBOR_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
  {
    auto & this_neighbor_mats =
        _materials[Moose::NEIGHBOR_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid);
    for (std::shared_ptr<MaterialBase> neighbor_mat : this_neighbor_mats)
      if (neighbor_mat->ghostable())
      {
        neighbor_materials.push_back(neighbor_mat);
#ifndef NDEBUG
        auto & var_deps = neighbor_mat->getMooseVariableDependencies();
        for (auto * var : var_deps)
        {
          if (!var->isFV())
            mooseError(
                "Ghostable materials should only have finite volume variables coupled into them.");
          else if (neighbor_mat->hasStatefulProperties())
            mooseError("Finite volume materials do not currently support stateful properties.");
          auto pr = variables.insert(var);
          mooseAssert(!pr.second,
                      "We should not have inserted any new variables dependencies from our "
                      "neighbor materials that didn't exist for our face materials");
        }
#endif
      }
  }
}

◆ getHitNode() [1/2]

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

inlineinherited

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

Definition at line 136 of file MooseBase.h.

136{ return getHitNode(_pars); }

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

◆ getHitNode() [2/2]

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

staticprivateinherited

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

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

Definition at line 167 of file MooseBase.C.

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

◆ getIndicatorWarehouse()

const MooseObjectWarehouse< Indicator > & FEProblemBase::getIndicatorWarehouse ( )

inline

Return indicator/marker storage.

Definition at line 2148 of file FEProblemBase.h.

2148{ return _indicators; }

◆ getInitialConditionWarehouse()

const InitialConditionWarehouse & FEProblemBase::getInitialConditionWarehouse ( ) const

inline

Return InitialCondition storage.

Definition at line 2159 of file FEProblemBase.h.

2159{ return _ics; }

Referenced by ComputeBoundaryInitialConditionThread::onNode(), ComputeInitialConditionThread::operator()(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), and ComputeInitialConditionThread::printGeneralExecutionInformation().

◆ getInterfaceMaterialsWarehouse()

const MaterialWarehouse & FEProblemBase::getInterfaceMaterialsWarehouse ( ) const

inline

Definition at line 2379 of file FEProblemBase.h.

2379{ return _interface_materials; }

Referenced by SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), and ComputeUserObjectsThread::getInterfaceMaterialReinitCache().

◆ getInternalSideIndicatorWarehouse()

const MooseObjectWarehouse< InternalSideIndicatorBase > & FEProblemBase::getInternalSideIndicatorWarehouse ( )

inline

Definition at line 2149 of file FEProblemBase.h.

  {
    return _internal_side_indicators;
  }

◆ getKokkosBndMaterialPropertyStorage()

Moose::Kokkos::MaterialPropertyStorage & FEProblemBase::getKokkosBndMaterialPropertyStorage ( )

inline

Definition at line 2133 of file FEProblemBase.h.

  {
    return _kokkos_bnd_material_props;
  }

◆ getKokkosFESystem() [1/2]

Moose::Kokkos::FESystem & FEProblemBase::getKokkosFESystem ( const unsigned int sys_num )

Get the Kokkos FESystem of a specified number.

Parameters

sys_num The system number

Returns: The Kokkos FESystem

◆ getKokkosFESystem() [2/2]

const Moose::Kokkos::FESystem & FEProblemBase::getKokkosFESystem ( const unsigned int sys_num ) const

◆ getKokkosFESystems() [1/2]

Moose::Kokkos::Array< Moose::Kokkos::FESystem > & FEProblemBase::getKokkosFESystems ( )

inline

Get the Kokkos FESystem array (populated only when FE Kokkos objects exist)

Returns: The array of Kokkos FESystem objects

Definition at line 904 of file FEProblemBase.h.

  {
    return _kokkos_fe_systems;
  }

◆ getKokkosFESystems() [2/2]

const Moose::Kokkos::Array< Moose::Kokkos::FESystem > & FEProblemBase::getKokkosFESystems ( ) const

inline

Definition at line 908 of file FEProblemBase.h.

  {
    return _kokkos_fe_systems;
  }

◆ getKokkosFunction() [1/2]

virtual Moose::Kokkos::Function FEProblemBase::getKokkosFunction ( const std::string & name )

virtual

Get a Kokkos function in an abstract type.

Parameters

name	The Kokkos function name

Returns: The copy of the Kokkos function in the abstract type

◆ getKokkosFunction() [2/2]

template<typename T >

T & FEProblemBase::getKokkosFunction ( const std::string & name )

Get a Kokkos function in a concrete type.

Template Parameters

T	The Kokkos function type

Parameters

name	The Kokkos function name

Returns: The reference of the Kokkos function in the concrete type

Definition at line 3974 of file FEProblemBase.h.

{
  if (!hasKokkosFunction(name))
  {
    // If we didn't find a function, it might be a default function, attempt to construct one now
    std::istringstream ss(name);
    Real real_value;
 
    // First see if it's just a constant. If it is, build a ConstantFunction
    if (ss >> real_value && ss.eof())
    {
      InputParameters params = _factory.getValidParams("KokkosConstantFunction");
      params.set<Real>("value") = real_value;
      addKokkosFunction("KokkosConstantFunction", ss.str(), params);
    }
 
    // Try once more
    if (!hasKokkosFunction(name))
      mooseError("Unable to find Kokkos function '" + name, "'");
  }
 
  auto * const ret = dynamic_cast<T *>(_kokkos_functions.getActiveObject(name).get());
  if (!ret)
    mooseError("No Kokkos function named '", name, "' of appropriate type");
 
  return *ret;
}

◆ getKokkosMaterialData()

MaterialData & FEProblemBase::getKokkosMaterialData	(	Moose::MaterialDataType	type,
		const MooseObject *	object = `nullptr`
	)		const

Returns: The Kokkos MaterialData for the type type for thread tid

Referenced by BlockRestrictable::initializeBlockRestrictable().

◆ getKokkosMaterialPropertyStorage()

Moose::Kokkos::MaterialPropertyStorage & FEProblemBase::getKokkosMaterialPropertyStorage ( )

inline

Definition at line 2129 of file FEProblemBase.h.

  {
    return _kokkos_material_props;
  }

◆ getKokkosMaterialPropertyStorageConsumers()

const std::set< const MooseObject * > & FEProblemBase::getKokkosMaterialPropertyStorageConsumers ( Moose::MaterialDataType type ) const

Returns: The consumers of the Kokkos MaterialPropertyStorage for the type type

◆ getKokkosMaterialsWarehouse()

const MaterialWarehouse & FEProblemBase::getKokkosMaterialsWarehouse ( ) const

inline

Definition at line 2385 of file FEProblemBase.h.

2385{ return _kokkos_materials; }

◆ getKokkosNeighborMaterialPropertyStorage()

Moose::Kokkos::MaterialPropertyStorage & FEProblemBase::getKokkosNeighborMaterialPropertyStorage ( )

inline

Definition at line 2137 of file FEProblemBase.h.

  {
    return _kokkos_neighbor_material_props;
  }

◆ getKokkosSystem() [1/2]

Moose::Kokkos::System & FEProblemBase::getKokkosSystem ( const unsigned int sys_num )

Get the Kokkos System of a specified number.

Parameters

sys_num The system number

Returns: The Kokkos System

◆ getKokkosSystem() [2/2]

const Moose::Kokkos::System & FEProblemBase::getKokkosSystem ( const unsigned int sys_num ) const

◆ getKokkosSystems() [1/2]

Moose::Kokkos::Array< Moose::Kokkos::System > & FEProblemBase::getKokkosSystems ( )

inline

Get the Kokkos System array (always populated when any Kokkos object exists)

Returns: The array of Kokkos System objects

Definition at line 892 of file FEProblemBase.h.

892{ return _kokkos_systems; }

FEProblemBase::_kokkos_systems

Moose::Kokkos::Array< Moose::Kokkos::System > _kokkos_systems

System array - sparsely populated (only slots for systems needing a Kokkos::System)

Definition FEProblemBase.h:3258

◆ getKokkosSystems() [2/2]

const Moose::Kokkos::Array< Moose::Kokkos::System > & FEProblemBase::getKokkosSystems ( ) const

inline

Definition at line 893 of file FEProblemBase.h.

  {
    return _kokkos_systems;
  }

◆ getKokkosUserObject()

template<class T >

const T & FEProblemBase::getKokkosUserObject ( const std::string & name ) const

inline

Get the Kokkos user object by its name.

Parameters

name	The name of the Kokkos user object being retrieved

Returns: const reference to the Kokkos user object

Definition at line 1461 of file FEProblemBase.h.

  {
    std::vector<T *> objs;
    theWarehouse()
        .query()
        .condition<AttribSystem>("KokkosUserObject")
        .condition<AttribName>(name)
        .queryInto(objs);
    if (objs.empty())
      mooseError("Unable to find Kokkos user object with name '" + name + "'");
    return *(objs[0]);
  }

Referenced by UserObjectInterface::getUserObjectFromFEProblem().

◆ getLinearConvergenceNames()

const std::vector< ConvergenceName > & FEProblemBase::getLinearConvergenceNames ( ) const

Gets the linear convergence object name(s).

Definition at line 10209 of file FEProblemBase.C.

{
  if (_linear_convergence_names)
    return *_linear_convergence_names;
  mooseError("The linear convergence name(s) have not been set.");
}

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

◆ getLinearSystem() [1/2]

LinearSystem & FEProblemBase::getLinearSystem ( unsigned int sys_num )

inline

Get non-constant reference to a linear system.

Parameters

sys_num The number of the linear system

Definition at line 3890 of file FEProblemBase.h.

{
  mooseAssert(sys_num < _linear_systems.size(),
              "System number greater than the number of linear systems");
  return *_linear_systems[sys_num];
}

Referenced by IterationAdaptiveDT::acceptStep(), Moose::compute_linear_system(), Moose::PetscSupport::petscSetDefaults(), and FEProblemSolve::solve().

◆ getLinearSystem() [2/2]

const LinearSystem & FEProblemBase::getLinearSystem ( unsigned int sys_num ) const

inline

Get a constant reference to a linear system.

Parameters

sys_num The number of the linear system

Definition at line 3898 of file FEProblemBase.h.

{
  mooseAssert(sys_num < _linear_systems.size(),
              "System number greater than the number of linear systems");
  return *_linear_systems[sys_num];
}

◆ getLinearSystemNames()

const std::vector< LinearSystemName > & FEProblemBase::getLinearSystemNames ( ) const

inline

Returns: the linear system names in the problem

Definition at line 3050 of file FEProblemBase.h.

3050{ return _linear_sys_names; }

Referenced by PhysicsBase::initializePhysics(), and MultiSystemSolveObject::MultiSystemSolveObject().

◆ getLineSearch()

LineSearch * FEProblemBase::getLineSearch ( )

inlineoverridevirtual

getter for the MOOSE line search

Implements SubProblem.

Definition at line 851 of file FEProblemBase.h.

851{ return _line_search.get(); }

Referenced by DisplacedProblem::getLineSearch().

◆ getMarkerWarehouse()

const MooseObjectWarehouse< Marker > & FEProblemBase::getMarkerWarehouse ( )

inline

Definition at line 2153 of file FEProblemBase.h.

2153{ return _markers; }

◆ getMaterial()

std::shared_ptr< MaterialBase > FEProblemBase::getMaterial	(	std::string	name,
		Moose::MaterialDataType	type,
		const THREAD_ID	tid = `0`,
		bool	no_warn = `false`
	)

Return a pointer to a MaterialBase object.

If no_warn is true, suppress warning about retrieving a material reference potentially during the material's calculation.

This will return enabled or disabled objects, the main purpose is for iterative materials.

Definition at line 4058 of file FEProblemBase.C.

{
  switch (type)
  {
    case Moose::NEIGHBOR_MATERIAL_DATA:
      name += "_neighbor";
      break;
    case Moose::FACE_MATERIAL_DATA:
      name += "_face";
      break;
    default:
      break;
  }
 
  std::shared_ptr<MaterialBase> material = _all_materials[type].getActiveObject(name, tid);
  if (!no_warn && material->getParam<bool>("compute") && type == Moose::BLOCK_MATERIAL_DATA)
    mooseWarning("You are retrieving a Material object (",
                 material->name(),
                 "), but its compute flag is set to true. This indicates that MOOSE is "
                 "computing this property which may not be desired and produce un-expected "
                 "results.");
 
  return material;
}

Referenced by MaterialPropertyInterface::getMaterialByName().

◆ getMaterialData()

MaterialData & FEProblemBase::getMaterialData	(	Moose::MaterialDataType	type,
		const THREAD_ID	tid = `0`,
		const MooseObject *	object = `nullptr`
	)		const

Returns: The MaterialData for the type type for thread tid

Definition at line 4087 of file FEProblemBase.C.

{
  switch (type)
  {
    case Moose::BLOCK_MATERIAL_DATA:
      if (object)
        _material_props.addConsumer(type, object);
      return _material_props.getMaterialData(tid);
    case Moose::NEIGHBOR_MATERIAL_DATA:
      if (object)
        _neighbor_material_props.addConsumer(type, object);
      return _neighbor_material_props.getMaterialData(tid);
    case Moose::BOUNDARY_MATERIAL_DATA:
    case Moose::FACE_MATERIAL_DATA:
    case Moose::INTERFACE_MATERIAL_DATA:
      if (object)
        _bnd_material_props.addConsumer(type, object);
      return _bnd_material_props.getMaterialData(tid);
  }
 
  mooseError("FEProblemBase::getMaterialData(): Invalid MaterialDataType ", type);
}

Referenced by BlockRestrictable::initializeBlockRestrictable(), and resizeMaterialData().

◆ getMaterialPropertyBlockNames()

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

virtualinherited

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

Definition at line 481 of file SubProblem.C.

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

Referenced by MaterialPropertyInterface::getMaterialPropertyBlockNames().

◆ getMaterialPropertyBlocks()

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

virtualinherited

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

Definition at line 465 of file SubProblem.C.

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

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

◆ getMaterialPropertyBoundaryIDs()

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

virtualinherited

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

Definition at line 517 of file SubProblem.C.

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

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

◆ getMaterialPropertyBoundaryNames()

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

virtualinherited

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

Definition at line 533 of file SubProblem.C.

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

Referenced by MaterialPropertyInterface::getMaterialPropertyBoundaryNames().

◆ getMaterialPropertyRegistry()

const MaterialPropertyRegistry & FEProblemBase::getMaterialPropertyRegistry ( ) const

inline

Returns: A reference to the material property registry

Definition at line 2111 of file FEProblemBase.h.

  {
    return _material_prop_registry;
  }

Referenced by DiffusionCG::addFEKernels(), SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), and MaterialBase::checkStatefulSanity().

◆ getMaterialPropertyStorage()

const MaterialPropertyStorage & FEProblemBase::getMaterialPropertyStorage ( )

inline

Return a reference to the material property storage.

Returns: A const reference to the material property storage

Definition at line 2121 of file FEProblemBase.h.

2121{ return _material_props; }

◆ getMaterialPropertyStorageConsumers()

const std::set< const MooseObject * > & FEProblemBase::getMaterialPropertyStorageConsumers ( Moose::MaterialDataType type ) const

Returns: The consumers of the MaterialPropertyStorage for the type type

Definition at line 4113 of file FEProblemBase.C.

{
  switch (type)
  {
    case Moose::BLOCK_MATERIAL_DATA:
      return _material_props.getConsumers(type);
    case Moose::NEIGHBOR_MATERIAL_DATA:
      return _neighbor_material_props.getConsumers(type);
    case Moose::BOUNDARY_MATERIAL_DATA:
    case Moose::FACE_MATERIAL_DATA:
    case Moose::INTERFACE_MATERIAL_DATA:
      return _bnd_material_props.getConsumers(type);
  }
 
  mooseError("FEProblemBase::getMaterialPropertyStorageConsumers(): Invalid MaterialDataType ",
             type);
}

◆ getMaterialWarehouse()

const MaterialWarehouse & FEProblemBase::getMaterialWarehouse ( ) const

inline

Definition at line 2372 of file FEProblemBase.h.

2372{ return _all_materials; }

Referenced by MaterialPropertyInterface::buildRequiredMaterials(), BlockRestrictable::hasBlockMaterialPropertyHelper(), BoundaryRestrictable::hasBoundaryMaterialPropertyHelper(), ElementSubdomainModifierBase::modify(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), MaterialPropertyDebugOutput::printMaterialMap(), ComputeIndicatorThread::subdomainChanged(), and ComputeUserObjectsThread::subdomainChanged().

◆ getMatrixTagID()

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

virtualinherited

Get a TagID from a TagName.

Reimplemented in DisplacedProblem.

Definition at line 334 of file SubProblem.C.

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

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

◆ getMatrixTags()

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

inlinevirtualinherited

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

Definition at line 256 of file SubProblem.h.

256{ return _matrix_tag_name_to_tag_id; }

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

◆ getMaxQps()

unsigned int FEProblemBase::getMaxQps ( ) const

Returns: The maximum number of quadrature points in use on any element in this problem.

Definition at line 1810 of file FEProblemBase.C.

{
  if (_max_qps == std::numeric_limits<unsigned int>::max())
    mooseError("Max QPS uninitialized");
  return _max_qps;
}

Referenced by MaterialBase::getMaxQps(), MaterialPropertyInterface::getMaxQps(), reinitDirac(), Material::subdomainSetup(), and updateMaxQps().

◆ getMaxScalarOrder()

Order FEProblemBase::getMaxScalarOrder ( ) const

Returns: The maximum order for all scalar variables in this problem's systems.

Definition at line 1818 of file FEProblemBase.C.

{
  return _max_scalar_order;
}

Referenced by ScalarCoupleable::coupledScalarOrder(), ScalarCoupleable::getADDefaultValue(), and ScalarCoupleable::getDefaultValue().

◆ getMeshDivision()

MeshDivision & FEProblemBase::getMeshDivision	(	const std::string &	name,
		const THREAD_ID	tid = `0`
	)		const

Get a MeshDivision.

Definition at line 2885 of file FEProblemBase.C.

{
  auto * const ret = dynamic_cast<MeshDivision *>(_mesh_divisions.getActiveObject(name, tid).get());
  if (!ret)
    mooseError("No MeshDivision object named ", name, " of appropriate type");
  return *ret;
}

Referenced by NestedDivision::NestedDivision().

◆ getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

87{ return _app; }

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

◆ getMortarInterface() [1/2]

AutomaticMortarGeneration & FEProblemBase::getMortarInterface	(	const std::pair< BoundaryID, BoundaryID > &	primary_secondary_boundary_pair,
		const std::pair< SubdomainID, SubdomainID > &	primary_secondary_subdomain_pair,
		bool	on_displaced
	)

Definition at line 8815 of file FEProblemBase.C.

{
  return _mortar_data->getMortarInterface(
      primary_secondary_boundary_pair, primary_secondary_subdomain_pair, on_displaced);
}

◆ getMortarInterface() [2/2]

const AutomaticMortarGeneration & FEProblemBase::getMortarInterface	(	const std::pair< BoundaryID, BoundaryID > &	primary_secondary_boundary_pair,
		const std::pair< SubdomainID, SubdomainID > &	primary_secondary_subdomain_pair,
		bool	on_displaced
	)		const

Return the undisplaced or displaced mortar generation object associated with the provided boundaries and subdomains.

Definition at line 8805 of file FEProblemBase.C.

{
  return _mortar_data->getMortarInterface(
      primary_secondary_boundary_pair, primary_secondary_subdomain_pair, on_displaced);
}

◆ getMortarInterfaces()

const std::unordered_map< std::pair< BoundaryID, BoundaryID >, MortarInterfaceConfig > & FEProblemBase::getMortarInterfaces ( bool on_displaced ) const

Definition at line 10497 of file FEProblemBase.C.

{
  return _mortar_data->getMortarInterfaces(on_displaced);
}

Referenced by computeUserObjectsInternal(), MortarSegmentMeshReporter::execute(), and NonlinearSystemBase::initialSetup().

◆ getMortarUserObjects() [1/2]

std::vector< MortarUserObject * > FEProblemBase::getMortarUserObjects	(	BoundaryID	primary_boundary_id,
		BoundaryID	secondary_boundary_id,
		bool	displaced
	)

private

Helper for getting mortar objects corresponding to primary boundary ID, secondary boundary ID, and displaced parameters from the entire active mortar user object set.

Definition at line 10322 of file FEProblemBase.C.

{
  std::vector<MortarUserObject *> mortar_uos;
  theWarehouse()
      .query()
      .condition<AttribInterfaces>(Interfaces::MortarUserObject)
      .queryInto(mortar_uos);
  return getMortarUserObjects(primary_boundary_id, secondary_boundary_id, displaced, mortar_uos);
}

◆ getMortarUserObjects() [2/2]

std::vector< MortarUserObject * > FEProblemBase::getMortarUserObjects	(	BoundaryID	primary_boundary_id,
		BoundaryID	secondary_boundary_id,
		bool	displaced,
		const std::vector< MortarUserObject * > &	mortar_uo_superset
	)

private

Helper for getting mortar objects corresponding to primary boundary ID, secondary boundary ID, and displaced parameters, given some initial set.

Definition at line 10305 of file FEProblemBase.C.

{
  std::vector<MortarUserObject *> mortar_uos;
  auto * const subproblem =
      displaced ? cast_ptr<SubProblem *>(_displaced_problem.get()) : cast_ptr<SubProblem *>(this);
  for (auto * const obj : mortar_uo_superset)
    if (obj->onInterface(primary_boundary_id, secondary_boundary_id) &&
        (&obj->getSubProblem() == subproblem))
      mortar_uos.push_back(obj);
 
  return mortar_uos;
}

Referenced by computeUserObjectsInternal(), getMortarUserObjects(), and reinitMortarUserObjects().

◆ getMultiApp()

std::shared_ptr< MultiApp > FEProblemBase::getMultiApp ( const std::string & multi_app_name ) const

Get a MultiApp object by name.

Definition at line 5976 of file FEProblemBase.C.

{
  if (!hasMultiApp(multi_app_name))
    mooseAssert(getMooseApp().actionWarehouse().isTaskComplete("add_multi_app"),
                "A MultiApp getter was called before MultiApps have been constructed. "
                "If you are attempting to access this object in the constructor of another object "
                "then make sure that the MultiApp is constructed before the object using it.");
 
  return _multi_apps.getObject(multi_app_name);
}

Referenced by addTransfer(), execMultiAppTransfers(), MultiAppPositions::initialize(), and MultiAppTransfer::MultiAppTransfer().

◆ getMultiAppFixedPointConvergenceName()

const ConvergenceName & FEProblemBase::getMultiAppFixedPointConvergenceName ( ) const

Gets the MultiApp fixed point convergence object name.

Definition at line 10217 of file FEProblemBase.C.

{
  if (_multiapp_fixed_point_convergence_name)
    return _multiapp_fixed_point_convergence_name.value();
  else
    mooseError("The fixed point convergence name has not been set.");
}

Referenced by addDefaultMultiAppFixedPointConvergence(), FixedPointSolve::examineFixedPointConvergence(), FixedPointIterationAdaptiveDT::init(), FixedPointSolve::initialSetup(), SteffensenSolve::initialSetup(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

◆ getMultiAppTransferWarehouse()

const ExecuteMooseObjectWarehouse< Transfer > & FEProblemBase::getMultiAppTransferWarehouse ( Transfer::DIRECTION direction ) const

Return the complete warehouse for MultiAppTransfer object for the given direction.

Definition at line 6122 of file FEProblemBase.C.

{
  if (direction == MultiAppTransfer::TO_MULTIAPP)
    return _to_multi_app_transfers;
  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
    return _from_multi_app_transfers;
  else
    return _between_multi_app_transfers;
}

◆ getMultiAppWarehouse()

ExecuteMooseObjectWarehouse< MultiApp > & FEProblemBase::getMultiAppWarehouse ( )

inline

Definition at line 2644 of file FEProblemBase.h.

2644{ return _multi_apps; }

Referenced by MooseApp::collectCitations(), MooseApp::errorCheck(), and MooseApp::setOutputFileBase().

◆ getNeighborMaterialPropertyStorage()

const MaterialPropertyStorage & FEProblemBase::getNeighborMaterialPropertyStorage ( )

inline

Definition at line 2123 of file FEProblemBase.h.

  {
    return _neighbor_material_props;
  }

◆ getNonlinearConvergenceNames()

const std::vector< ConvergenceName > & FEProblemBase::getNonlinearConvergenceNames ( ) const

Gets the nonlinear system convergence object name(s).

Definition at line 10185 of file FEProblemBase.C.

{
  if (_nonlinear_convergence_names)
    return *_nonlinear_convergence_names;
  mooseError("The nonlinear system convergence name(s) have not been set.");
}

Referenced by addDefaultNonlinearConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), and FEProblemSolve::convergenceSetup().

◆ getNonlinearEvaluableElementRange()

const ConstElemRange & FEProblemBase::getNonlinearEvaluableElementRange ( )

Definition at line 946 of file FEProblemBase.C.

{
  if (!_nl_evaluable_local_elem_range)
  {
    std::vector<const DofMap *> dof_maps(_nl.size());
    for (const auto i : index_range(dof_maps))
      dof_maps[i] = &_nl[i]->dofMap();
    _nl_evaluable_local_elem_range =
        std::make_unique<ConstElemRange>(_mesh.getMesh().multi_evaluable_elements_begin(dof_maps),
                                         _mesh.getMesh().multi_evaluable_elements_end(dof_maps));
  }
 
  return *_nl_evaluable_local_elem_range;
}

Referenced by ElemSideNeighborLayersTester::execute().

◆ getNonlinearSystem()

NonlinearSystem & FEProblemBase::getNonlinearSystem ( const unsigned int sys_num )

virtual

Reimplemented in FEProblem.

Definition at line 2900 of file FEProblemBase.C.

{
  mooseDeprecated("FEProblemBase::getNonlinearSystem() is deprecated, please use "
                  "FEProblemBase::getNonlinearSystemBase() \n");
 
  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
  auto nl_sys = std::dynamic_pointer_cast<NonlinearSystem>(_nl[sys_num]);
 
  if (!nl_sys)
    mooseError("This is not a NonlinearSystem");
 
  return *nl_sys;
}

Referenced by PNGOutput::calculateRescalingValues(), and PNGOutput::makeMeshFunc().

◆ getNonlinearSystemBase() [1/2]

NonlinearSystemBase & FEProblemBase::getNonlinearSystemBase ( const unsigned int sys_num )

inline

Definition at line 3846 of file FEProblemBase.h.

{
  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
  return *_nl[sys_num];
}

Referenced by IterationAdaptiveDT::acceptStep(), DisplacedProblem::addTimeIntegrator(), ADKernelTempl< T >::ADKernelTempl(), ElementSubdomainModifierBase::applyIC(), ArrayKernel::ArrayKernel(), Eigenvalue::checkIntegrity(), PseudoTimestep::currentResidualNorm(), DisplacedProblem::DisplacedProblem(), AB2PredictorCorrector::estimateTimeError(), GreaterThanLessThanPostprocessor::execute(), MatrixSymmetryCheck::execute(), VariableResidual::execute(), Executioner::Executioner(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), NumResidualEvaluations::getValue(), Residual::getValue(), ActivateElementsUserObjectBase::initSolutions(), Kernel::Kernel(), ReferenceResidualConvergence::nonlinearSystem(), BoundaryElemIntegrityCheckThread::operator()(), DOFMapOutput::output(), SolutionHistory::output(), ConsoleUtils::outputExecutionInformation(), Console::outputSystemInformation(), Moose::PetscSupport::petscSetDefaults(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Moose::PetscSupport::setLineSearchFromParams(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), AB2PredictorCorrector::step(), DisplacedProblem::syncSolutions(), and Console::writeVariableNorms().

◆ getNonlinearSystemBase() [2/2]

const NonlinearSystemBase & FEProblemBase::getNonlinearSystemBase ( const unsigned int sys_num ) const

inline

Definition at line 3853 of file FEProblemBase.h.

{
  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
  return *_nl[sys_num];
}

◆ getNonlinearSystemNames()

const std::vector< NonlinearSystemName > & FEProblemBase::getNonlinearSystemNames ( ) const

inline

Returns: the nolinear system names in the problem

Definition at line 3046 of file FEProblemBase.h.

3046{ return _nl_sys_names; }

Referenced by PhysicsBase::initializePhysics(), Console::meshChanged(), MultiSystemSolveObject::MultiSystemSolveObject(), ConsoleUtils::outputExecutionInformation(), and Console::outputSystemInformation().

◆ getNumCyclesCompleted()

unsigned int FEProblemBase::getNumCyclesCompleted ( )

inline

Returns: The number of adaptivity cycles completed.

Definition at line 2189 of file FEProblemBase.h.

2189{ return _cycles_completed; }

◆ getParam() [1/2]

template<typename T >

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

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns: The value of the parameter

Definition at line 406 of file MooseBase.h.

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

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

◆ getParam() [2/2]

template<typename T1 , typename T2 >

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

inherited

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

Parameters

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

Returns: Vector of pairs of first and second parameters

Definition at line 443 of file MooseBase.h.

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

◆ getPetscOptions()

Moose::PetscSupport::PetscOptions & FEProblemBase::getPetscOptions ( )

inline

Retrieve a writable reference the PETSc options (used by PetscSupport)

Definition at line 698 of file FEProblemBase.h.

698{ return _petsc_options; }

FEProblemBase::_petsc_options

Moose::PetscSupport::PetscOptions _petsc_options

PETSc option storage.

Definition FEProblemBase.h:3567

Referenced by MFEMPetscNonlinearSolver::ConstructSolver(), Moose::PetscSupport::dontAddCommonKSPOptions(), Moose::PetscSupport::dontAddCommonSNESOptions(), Moose::PetscSupport::dontAddLinearConvergedReason(), Moose::PetscSupport::dontAddNonlinearConvergedReason(), EigenProblemSolve::EigenProblemSolve(), Moose::PetscSupport::isSNESVI(), ConsoleUtils::outputExecutionInformation(), Moose::PetscSupport::setConvergedReasonFlags(), Moose::SlepcSupport::setSlepcEigenSolverTolerances(), Split::setup(), Moose::SlepcSupport::slepcSetOptions(), FEProblemSolve::solve(), and Moose::PetscSupport::storePetscOptions().

◆ getPositionsObject()

const Positions & FEProblemBase::getPositionsObject ( const std::string & name ) const

Get the Positions object by its name.

Parameters

name	The name of the Positions object being retrieved

Returns: Const reference to the Positions object

Definition at line 4834 of file FEProblemBase.C.

{
  std::vector<Positions *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>("UserObject")
      .condition<AttribName>(name)
      .queryInto(objs);
  if (objs.empty())
    mooseError("Unable to find Positions object with name '" + name + "'");
  mooseAssert(objs.size() == 1, "Should only find one Positions");
  return *(objs[0]);
}

Referenced by DistributedPositions::DistributedPositions(), MultiApp::fillPositions(), ParsedDownSelectionPositions::initialize(), Positions::initialized(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), and TransformedPositions::TransformedPositions().

◆ getPostprocessorObjectByName()

const Postprocessor & FEProblemBase::getPostprocessorObjectByName	(	const PostprocessorName &	object_name,
		const THREAD_ID	tid = `0`
	)		const

Return the Postprocessor object registered under the supplied object name.

Parameters

object_name	The name of the Postprocessor object
tid	The thread identifier for thread-local object lookup

Definition at line 4980 of file FEProblemBase.C.

{
  std::vector<Postprocessor *> objs;
  theWarehouse()
      .query()
      .condition<AttribInterfaces>(Interfaces::Postprocessor)
      .condition<AttribThread>(tid)
      .condition<AttribName>(object_name)
      .queryInto(objs);
 
  if (objs.empty())
    mooseError("Unable to find Postprocessor with name '", object_name, "'");
  mooseAssert(objs.size() == 1,
              "We shouldn't find more than one postprocessor object for a given name");
  return *(objs[0]);
}

◆ getPostprocessorValueByName()

const PostprocessorValue & FEProblemBase::getPostprocessorValueByName	(	const PostprocessorName &	name,
		std::size_t	t_index = `0`
	)		const

Get a read-only reference to the value associated with a Postprocessor that exists.

Parameters

name	The name of the post-processor
t_index	Flag for getting current (0), old (1), or older (2) values

Returns: The reference to the value at the given time index

Note: This method is only for retrieving values that already exist, the Postprocessor and PostprocessorInterface objects should be used rather than this method for creating and getting values within objects.

Definition at line 4999 of file FEProblemBase.C.

{
  return _reporter_data.getReporterValue<PostprocessorValue>(PostprocessorReporterName(name),
                                                             t_index);
}

Referenced by MFEMProblem::addPostprocessor(), MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiApp::appPostprocessorValue(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppPostprocessorTransfer::execute(), EigenProblem::formNorm(), MooseParsedFunctionWrapper::initialize(), ParsedConvergence::initializePostprocessorSymbol(), EigenExecutionerBase::inversePowerIteration(), Exodus::outputPostprocessors(), Nemesis::outputPostprocessors(), TableOutput::outputPostprocessorsRow(), EigenProblem::postScaleEigenVector(), and TableOutput::shouldOutputPostprocessorsRow().

◆ getRegularMaterialsWarehouse()

const MaterialWarehouse & FEProblemBase::getRegularMaterialsWarehouse ( ) const

inline

Definition at line 2377 of file FEProblemBase.h.

2377{ return _materials; }

Referenced by ComputeUserObjectsThread::getInterfaceMaterialReinitCache(), ComputeUserObjectsThread::getInternalSideMaterialReinitCache(), and Moose::Mortar::setupMortarMaterials().

◆ getRenamedParam()

template<typename T >

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

inherited

Retrieve a renamed parameter for the object.

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

Parameters

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

Definition at line 420 of file MooseBase.h.

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

◆ getReporterData() [1/2]

const ReporterData & FEProblemBase::getReporterData ( ) const

inline

Provides const access the ReporterData object.

NOTE: There is a private non-const version of this function that uses a key object only constructable by the correct interfaces. This was done by design to encourage the use of the Reporter and ReporterInterface classes.

Definition at line 1402 of file FEProblemBase.h.

1402{ return _reporter_data; }

◆ getReporterData() [2/2]

ReporterData & FEProblemBase::getReporterData ( ReporterData::WriteKey )

inline

Provides non-const access the ReporterData object that is used to store reporter values.

see ReporterData.h

Definition at line 1409 of file FEProblemBase.h.

1409{ return _reporter_data; }

◆ getRestartableData()

template<typename T , typename... Args>

const T & Restartable::getRestartableData ( const std::string & data_name ) const

protectedinherited

Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object.

Forwarded arguments are not allowed in this case because we assume that the object is restarted and we won't need different constructors to initialize it.

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

Parameters

data_name The name of the data (usually just use the same name as the member variable)

Definition at line 294 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, nullptr).get();
}

◆ getRestartableEquationSystems()

const RestartableEquationSystems & FEProblemBase::getRestartableEquationSystems ( ) const

Get the RestartableEquationSystems object.

Definition at line 6653 of file FEProblemBase.C.

{
  return _req.get();
}

Referenced by LinearFVGradientManager::checkRestartedGradientHistory().

◆ getSampler()

Sampler & FEProblemBase::getSampler	(	const std::string &	name,
		const THREAD_ID	tid = `0`
	)

virtual

Definition at line 2966 of file FEProblemBase.C.

{
  std::vector<Sampler *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>("Sampler")
      .condition<AttribThread>(tid)
      .condition<AttribName>(name)
      .queryInto(objs);
  if (objs.empty())
  {
    mooseAssert(getMooseApp().actionWarehouse().isTaskComplete("add_sampler"),
                "A Sampler getter was called before Samplers have been constructed. "
                "If you are attempting to access this object in the constructor of another object "
                "then make sure that the Sampler is constructed before the object using it.");
 
    mooseError(
        "Unable to find Sampler with name '" + name +
        "', if you are attempting to access this object in the constructor of another object then "
        "make sure that the Sampler is constructed before the object using it.");
  }
  return *(objs[0]);
}

Referenced by SamplerInterface::getSampler(), and SamplerInterface::getSamplerByName().

◆ getScalarVariable()

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

overridevirtual

Returns the scalar variable reference from whichever system contains it.

Implements SubProblem.

Definition at line 6629 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    if (sys->hasScalarVariable(var_name))
      return sys->getScalarVariable(tid, var_name);
  if (_aux->hasScalarVariable(var_name))
    return _aux->getScalarVariable(tid, var_name);
 
  mooseError("Unknown variable " + var_name);
}

Referenced by addInitialCondition(), EigenProblem::adjustEigenVector(), MultiAppScalarToAuxScalarTransfer::execute(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), Exodus::outputScalarVariables(), Nemesis::outputScalarVariables(), and TableOutput::outputScalarVariables().

◆ getSharedPtr() [1/2]

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

inherited

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

Wrapper around shared_from_this().

Definition at line 70 of file MooseObject.C.

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

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

◆ getSharedPtr() [2/2]

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

inherited

Definition at line 83 of file MooseObject.C.

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

◆ getSolverSystem() [1/2]

SolverSystem & FEProblemBase::getSolverSystem ( unsigned int sys_num )

inline

Get non-constant reference to a solver system.

Parameters

sys_num The number of the solver system

Definition at line 3860 of file FEProblemBase.h.

{
  mooseAssert(sys_num < _solver_systems.size(),
              "System number greater than the number of solver systems");
  return *_solver_systems[sys_num];
}

Referenced by Adaptivity::adaptMesh(), Moose::PetscSupport::addPetscOptionsFromCommandline(), MooseApp::attachRelationshipManagers(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), Adaptivity::init(), FixedPointSolve::initialSetup(), MultiSystemSolveObject::MultiSystemSolveObject(), ConsoleUtils::outputSolverSystemInformation(), Moose::PetscSupport::petscSetDefaultKSPNormType(), and Moose::PetscSupport::petscSetDefaultPCSide().

◆ getSolverSystem() [2/2]

const SolverSystem & FEProblemBase::getSolverSystem ( unsigned int sys_num ) const

inline

Get a constant reference to a solver system.

Parameters

sys_num The number of the solver system

Definition at line 3868 of file FEProblemBase.h.

{
  mooseAssert(sys_num < _solver_systems.size(),
              "System number greater than the number of solver systems");
  return *_solver_systems[sys_num];
}

◆ getSolverSystemNames()

const std::vector< SolverSystemName > & FEProblemBase::getSolverSystemNames ( ) const

inline

Returns: the solver system names in the problem

Definition at line 3054 of file FEProblemBase.h.

3054{ return _solver_sys_names; }

Referenced by ConsoleUtils::outputExecutionInformation().

◆ getStandardVariable()

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

overridevirtual

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

Implements SubProblem.

Definition at line 6569 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    if (sys->hasVariable(var_name))
      return sys->getFieldVariable<Real>(tid, var_name);
  if (_aux->hasVariable(var_name))
    return _aux->getFieldVariable<Real>(tid, var_name);
 
  mooseError("Unknown variable " + var_name);
}

Referenced by CoupleableMooseVariableDependencyIntermediateInterface::coupledValueByName(), projectFunctionOnCustomRange(), LinearFVKernel::requestVariableCellGradient(), and ElementSubdomainModifierBase::storeOverriddenDofValues().

◆ getSteadyStateConvergenceName()

const ConvergenceName & FEProblemBase::getSteadyStateConvergenceName ( ) const

Gets the steady-state detection convergence object name.

Definition at line 10226 of file FEProblemBase.C.

{
  if (_steady_state_convergence_name)
    return _steady_state_convergence_name.value();
  else
    mooseError("The steady convergence name has not been set.");
}

Referenced by addDefaultSteadyStateConvergence(), TransientBase::convergedToSteadyState(), and TransientBase::init().

◆ getSystem()

System & FEProblemBase::getSystem ( const std::string & var_name )

overridevirtual

Returns the equation system containing the variable provided.

Implements SubProblem.

Definition at line 6641 of file FEProblemBase.C.

{
  const auto [var_in_sys, sys_num] = determineSolverSystem(var_name);
  if (var_in_sys)
    return _solver_systems[sys_num]->system();
  else if (_aux->hasVariable(var_name) || _aux->hasScalarVariable(var_name))
    return _aux->system();
  else
    mooseError("Unable to find a system containing the variable " + var_name);
}

Referenced by addObjectParamsHelper(), MultiApp::appTransferVector(), FunctorChangeFunctorMaterialTempl< is_ad >::FunctorChangeFunctorMaterialTempl(), ElementSubdomainModifierBase::gatherPatchElements(), and ElementSubdomainModifierBase::storeOverriddenDofValues().

◆ getSystemBase() [1/3]

SystemBase & FEProblemBase::getSystemBase ( const std::string & sys_name )

Get non-constant reference to a system in this problem.

Parameters

sys_name The name of the system

Definition at line 9944 of file FEProblemBase.C.

{
  if (std::find(_solver_sys_names.begin(), _solver_sys_names.end(), sys_name) !=
      _solver_sys_names.end())
    return getSystemBase(solverSysNum(sys_name));
  else if (sys_name == "aux0")
    return *_aux;
  else
    mooseError("System '" + sys_name + "' was requested from problem but does not exist.");
}

◆ getSystemBase() [2/3]

SystemBase & FEProblemBase::getSystemBase ( const unsigned int sys_num )

virtual

Get non-constant reference to a system in this problem.

Parameters

sys_num The number of the system

Definition at line 9956 of file FEProblemBase.C.

{
  if (sys_num < _solver_systems.size())
    return *_solver_systems[sys_num];
 
  return *_aux;
}

◆ getSystemBase() [3/3]

const SystemBase & FEProblemBase::getSystemBase ( const unsigned int sys_num ) const

virtual

Get constant reference to a system in this problem.

Parameters

sys_num The number of the system

Definition at line 9935 of file FEProblemBase.C.

{
  if (sys_num < _solver_systems.size())
    return *_solver_systems[sys_num];
 
  return *_aux;
}

Referenced by addObjectParamsHelper(), PhysicsBase::copyVariablesFromMesh(), getSystemBase(), projectFunctionOnCustomRange(), and ElementSubdomainModifierBase::restoreOverriddenDofValues().

◆ getTimeFromStateArg()

Real FEProblemBase::getTimeFromStateArg ( const Moose::StateArg & state ) const

Returns the time associated with the requested state.

Definition at line 7654 of file FEProblemBase.C.

{
  if (state.iteration_type != Moose::SolutionIterationType::Time)
    // If we are any iteration type other than time (e.g. nonlinear), then temporally we are still
    // in the present time
    return time();
 
  switch (state.state)
  {
    case 0:
      return time();
 
    case 1:
      return timeOld();
 
    case 2:
      return timeOlder();
 
    default:
      mooseError("Unhandled state ", state.state, " in FEProblemBase::getTimeFromStateArg");
  }
}

Referenced by Function::evaluate(), Function::evaluateDotHelper(), Function::evaluateGradientHelper(), Function::evaluateHelper(), and ParsedFunctorMaterialTempl< is_ad >::ParsedFunctorMaterialTempl().

◆ getTransfers() [1/2]

std::vector< std::shared_ptr< Transfer > > FEProblemBase::getTransfers	(	ExecFlagType	type,
		Transfer::DIRECTION	direction
	)		const

Get Transfers by ExecFlagType and direction.

Definition at line 6100 of file FEProblemBase.C.

{
  if (direction == MultiAppTransfer::TO_MULTIAPP)
    return _to_multi_app_transfers[type].getActiveObjects();
  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
    return _from_multi_app_transfers[type].getActiveObjects();
  else
    return _between_multi_app_transfers[type].getActiveObjects();
}

◆ getTransfers() [2/2]

std::vector< std::shared_ptr< Transfer > > FEProblemBase::getTransfers ( Transfer::DIRECTION direction ) const

Definition at line 6111 of file FEProblemBase.C.

{
  if (direction == MultiAppTransfer::TO_MULTIAPP)
    return _to_multi_app_transfers.getActiveObjects();
  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
    return _from_multi_app_transfers.getActiveObjects();
  else
    return _between_multi_app_transfers.getActiveObjects();
}

◆ getUOExecutionGroups()

void FEProblemBase::getUOExecutionGroups	(	TheWarehouse::Query &	query,
		std::set< int > &	execution_groups
	)		const

private

Definition at line 5406 of file FEProblemBase.C.

{
  std::vector<UserObjectBase *> uos;
  query.queryIntoUnsorted(uos);
  for (const auto & uo : uos)
    execution_groups.insert(uo->getParam<int>("execution_order_group"));
}

Referenced by computeUserObjectByName(), and computeUserObjects().

◆ getUOQuery()

TheWarehouse::Query FEProblemBase::getUOQuery	(	const std::string &	system,
		const ExecFlagType &	type,
		const Moose::AuxGroup &	group
	)		const

private

Definition at line 5388 of file FEProblemBase.C.

{
  TheWarehouse::Query query =
      theWarehouse().query().condition<AttribSystem>(system).condition<AttribExecOns>(type);
 
  if (group == Moose::PRE_IC)
    query.condition<AttribPreIC>(true);
  else if (group == Moose::PRE_AUX)
    query.condition<AttribPreAux>(type);
  else if (group == Moose::POST_AUX)
    query.condition<AttribPostAux>(type);
 
  return query;
}

Referenced by computeUserObjectByName(), and computeUserObjects().

◆ getUserObject()

template<class T >

T & FEProblemBase::getUserObject	(	const std::string &	name,
		unsigned int	tid = `0`
	)		const

inline

Get the user object by its name.

Parameters

name	The name of the user object being retrieved

Returns: Reference to the user object

Definition at line 1421 of file FEProblemBase.h.

  {
    std::vector<T *> objs;
    theWarehouse()
        .query()
        .condition<AttribSystem>("UserObject")
        .condition<AttribThread>(tid)
        .condition<AttribName>(name)
        .queryInto(objs);
    if (objs.empty())
      mooseError("Unable to find user object with name '" + name + "'");
    return *(objs[0]);
  }

Referenced by ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), ReporterTransferInterface::hideVariableHelper(), EigenExecutionerBase::init(), EigenProblemSolve::initialSetup(), IntegralPreservingFunctionIC::initialSetup(), ElementSubdomainModifierBase::initialSetup(), EigenExecutionerBase::inversePowerIteration(), and NEML2FEInterpolation::syncWithMainThread().

◆ getUserObjectBase()

const UserObject & FEProblemBase::getUserObjectBase	(	const std::string &	name,
		const THREAD_ID	tid = `0`
	)		const

Get the user object by its name.

Parameters

name	The name of the user object being retrieved
tid	The thread of the user object (defaults to 0)

Returns: Const reference to the user object

Definition at line 4811 of file FEProblemBase.C.

{
  std::vector<UserObject *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>("UserObject")
      .condition<AttribThread>(tid)
      .condition<AttribName>(name)
      .queryInto(objs);
  if (objs.empty())
  {
    mooseAssert(getMooseApp().actionWarehouse().isTaskComplete("add_user_object"),
                "A UserObject getter was called before UserObjects have been constructed. The "
                "requested UserObject '" +
                    name + "' may exist in the input file, but UserObjects are not available yet.");
 
    mooseError("Unable to find user object with name '" + name + "'");
  }
  mooseAssert(objs.size() == 1, "Should only find one UO");
  return *(objs[0]);
}

Referenced by MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiApp::appUserObjectBase(), EigenProblem::checkProblemIntegrity(), checkUserObjectNameCollision(), UserObjectInterface::getUserObjectFromFEProblem(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppConservativeTransfer::initialSetup(), and Terminator::initialSetup().

◆ getUserObjectJacobianVariables()

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

inline

Definition at line 356 of file FEProblemBase.h.

  {
    return _uo_jacobian_moose_vars[tid];
  }

Referenced by ComputeUserObjectsThread::onBoundary(), and ComputeUserObjectsThread::onElement().

◆ getVariable() [1/3]

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

inlinevirtual

Reimplemented from SubProblem.

Definition at line 282 of file SubProblem.h.

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

◆ getVariable() [2/3]

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

overridevirtual

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

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

Implements SubProblem.

Definition at line 6559 of file FEProblemBase.C.

{
  return getVariableHelper(
      tid, var_name, expected_var_type, expected_var_field_type, _solver_systems, *_aux);
}

Referenced by addFVInitialCondition(), addInitialCondition(), EigenProblem::adjustEigenVector(), MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppGeneralFieldShapeEvaluationTransfer::buildMeshFunctions(), CoupleableMooseVariableDependencyIntermediateInterface::coupledArrayValueByName(), CoupleableMooseVariableDependencyIntermediateInterface::coupledValueByName(), MultiAppGeometricInterpolationTransfer::execute(), MultiAppProjectionTransfer::execute(), MultiAppUserObjectTransfer::execute(), NodalNormalsCorner::execute(), NodalNormalsEvaluator::execute(), NodalNormalsPreprocessor::execute(), FunctorNodalCorrector::FunctorNodalCorrector(), NEML2FEInterpolation::getMOOSEVariable(), LazyCoupleable::init(), AdvancedOutput::initAvailableLists(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), MultiAppProjectionTransfer::initialSetup(), AdvancedOutput::initShowHideLists(), MultiApplibMeshToMFEMShapeEvaluationTransfer::interpolatelibMeshVariable(), PointwiseRenormalizeVector::PointwiseRenormalizeVector(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), MultiAppProjectionTransfer::projectSolution(), MultiAppDofCopyTransfer::transfer(), MultiAppShapeEvaluationTransfer::transferVariable(), and MultiAppMFEMTolibMeshShapeEvaluationTransfer::transferVariables().

◆ getVariable() [3/3]

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

virtual

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

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

Implements SubProblem.

◆ getVariableHelper() [1/2]

template<typename T >

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

protectedinherited

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

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

◆ getVariableHelper() [2/2]

template<typename T >

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

inherited

Definition at line 810 of file SubProblem.C.

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

◆ getVariableNames()

std::vector< VariableName > FEProblemBase::getVariableNames ( )

virtual

Returns a list of all the variables in the problem (both from the NL and Aux systems.

Definition at line 9644 of file FEProblemBase.C.

{
  std::vector<VariableName> names;
 
  for (auto & sys : _solver_systems)
  {
    const std::vector<VariableName> & var_names = sys->getVariableNames();
    names.insert(names.end(), var_names.begin(), var_names.end());
  }
 
  const std::vector<VariableName> & aux_var_names = _aux->getVariableNames();
  names.insert(names.end(), aux_var_names.begin(), aux_var_names.end());
 
  return names;
}

Referenced by EigenProblem::adjustEigenVector(), AdvancedOutput::initAvailableLists(), and ElementSubdomainModifierBase::initialSetup().

◆ getVectorPostprocessorObjectByName()

const VectorPostprocessor & FEProblemBase::getVectorPostprocessorObjectByName	(	const std::string &	object_name,
		const THREAD_ID	tid = `0`
	)		const

Return the VPP object given the name.

Parameters

object_name The name of the VPP object

Returns: Desired VPP object

This is used by various output objects as well as the scatter value handling.

See also: CSV.C, XMLOutput.C, VectorPostprocessorInterface.C

Definition at line 5043 of file FEProblemBase.C.

{
  std::vector<VectorPostprocessor *> objs;
  theWarehouse()
      .query()
      .condition<AttribInterfaces>(Interfaces::VectorPostprocessor)
      .condition<AttribThread>(tid)
      .condition<AttribName>(object_name)
      .queryInto(objs);
 
  if (objs.empty())
  {
    mooseAssert(
        getMooseApp().actionWarehouse().isTaskComplete("add_vector_postprocessor"),
        "A VectorPostprocessor getter was called before VectorPostprocessors have been "
        "constructed. The requested VectorPostprocessor '" +
            object_name +
            "' may exist in the input file, but VectorPostprocessors are not available yet.");
 
    mooseError("Unable to find VectorPostprocessor with name '", object_name, "'");
  }
  mooseAssert(objs.size() == 1,
              "We shouldn't find more than one vector postprocessor object for a given name");
  return *(objs[0]);
}

Referenced by CombinedVectorPostprocessor::CombinedVectorPostprocessor(), VectorPostprocessorInterface::isVectorPostprocessorDistributedByName(), CSV::output(), and XMLOutput::outputVectorPostprocessors().

◆ getVectorPostprocessorValueByName()

const VectorPostprocessorValue & FEProblemBase::getVectorPostprocessorValueByName	(	const std::string &	object_name,
		const std::string &	vector_name,
		std::size_t	t_index = `0`
	)		const

Get a read-only reference to the vector value associated with the VectorPostprocessor.

Parameters

object_name	The name of the VPP object.
vector_name	The namve of the decalred vector within the object.

Returns: Referent to the vector of data.

Note: This method is only for retrieving values that already exist, the VectorPostprocessor and VectorPostprocessorInterface objects should be used rather than this method for creating and getting values within objects.

Definition at line 5024 of file FEProblemBase.C.

{
  return _reporter_data.getReporterValue<VectorPostprocessorValue>(
      VectorPostprocessorReporterName(object_name, vector_name), t_index);
}

Referenced by HistogramVectorPostprocessor::execute().

◆ getVectorTag()

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

virtualinherited

Get a VectorTag from a TagID.

Reimplemented in DisplacedProblem.

Definition at line 153 of file SubProblem.C.

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

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

◆ getVectorTagID()

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

virtualinherited

Get a TagID from a TagName.

Reimplemented in DisplacedProblem.

Definition at line 195 of file SubProblem.C.

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

◆ getVectorTags() [1/2]

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

virtualinherited

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

Can optionally be limited to a vector tag type.

Reimplemented in DisplacedProblem.

Definition at line 176 of file SubProblem.C.

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

◆ getVectorTags() [2/2]

std::vector< VectorTag > SubProblem::getVectorTags ( const std::set< TagID > & tag_ids ) const

inherited

Definition at line 164 of file SubProblem.C.

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

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

◆ getVectorVariable()

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

overridevirtual

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

Implements SubProblem.

Definition at line 6593 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    if (sys->hasVariable(var_name))
      return sys->getFieldVariable<RealVectorValue>(tid, var_name);
  if (_aux->hasVariable(var_name))
    return _aux->getFieldVariable<RealVectorValue>(tid, var_name);
 
  mooseError("Unknown variable " + var_name);
}

◆ getXFEM()

std::shared_ptr< XFEMInterface > FEProblemBase::getXFEM ( )

inline

Get a pointer to the XFEM controller object.

Definition at line 2206 of file FEProblemBase.h.

2206{ return _xfem; }

FEProblemBase::_xfem

std::shared_ptr< XFEMInterface > _xfem

Pointer to XFEM controller.

Definition FEProblemBase.h:3430

◆ ghostedElems()

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

inlinevirtualinherited

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

Returns: The list

Reimplemented in DisplacedProblem.

Definition at line 683 of file SubProblem.h.

683{ return _ghosted_elems; }

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

◆ ghostGhostedBoundaries()

void FEProblemBase::ghostGhostedBoundaries ( )

overridevirtual

Causes the boundaries added using addGhostedBoundary to actually be ghosted.

Implements SubProblem.

Definition at line 2343 of file FEProblemBase.C.

{
  TIME_SECTION("ghostGhostedBoundaries", 3, "Ghosting Ghosted Boundaries");
 
  _mesh.ghostGhostedBoundaries();
 
  if (_displaced_problem)
    _displaced_mesh->ghostGhostedBoundaries();
}

Referenced by DisplacedProblem::ghostGhostedBoundaries(), init(), and meshChanged().

◆ handleException()

void FEProblemBase::handleException ( const std::string & calling_method )

private

Handle exceptions.

Note that the result of this call will be a thrown MooseException. The caller of this method must determine how to handle the thrown exception

Definition at line 8049 of file FEProblemBase.C.

{
  auto create_exception_message =
      [&calling_method](const std::string & exception_type, const auto & exception)
  {
    return std::string("A " + exception_type + " was raised during FEProblemBase::" +
                       calling_method + "\n" + std::string(exception.what()));
  };
 
  try
  {
    throw;
  }
  catch (const MooseException & e)
  {
    setException(create_exception_message("MooseException", e));
  }
  catch (const MetaPhysicL::LogicError & e)
  {
    moose::translateMetaPhysicLError(e);
  }
  catch (const libMesh::PetscSolverException & e)
  {
    // One PETSc solver exception that we cannot currently recover from are new nonzero errors. In
    // particular I have observed the following scenario in a parallel test:
    // - Both processes throw because of a new nonzero during MOOSE's computeJacobianTags
    // - We potentially handle the exceptions nicely here
    // - When the matrix is closed in libMesh's libmesh_petsc_snes_solver, there is a new nonzero
    //   throw which we do not catch here in MOOSE and the simulation terminates. This only appears
    //   in parallel (and not all the time; a test I was examining threw with distributed mesh, but
    //   not with replicated). In serial there are no new throws from libmesh_petsc_snes_solver.
    // So for uniformity of behavior across serial/parallel, we will choose to abort here and always
    // produce a non-zero exit code
    mooseError(create_exception_message("libMesh::PetscSolverException", e));
  }
  catch (const std::exception & e)
  {
    // This might be libMesh detecting a degenerate Jacobian or matrix
    if (strstr(e.what(), "Jacobian") || strstr(e.what(), "singular") ||
        strstr(e.what(), "det != 0"))
      setException(create_exception_message("libMesh DegenerateMap", e));
    else
    {
      const auto message = create_exception_message("std::exception", e);
      if (_regard_general_exceptions_as_errors)
        mooseError(message);
      else
        setException(message);
    }
  }
 
  checkExceptionAndStopSolve();
}

Referenced by computeBounds(), computeJacobianTags(), computeResidualAndJacobian(), computeResidualTags(), and computeUserObjectsInternal().

◆ hasActiveElementalMooseVariables()

bool SubProblem::hasActiveElementalMooseVariables ( const THREAD_ID tid ) const

virtualinherited

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

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

Definition at line 452 of file SubProblem.C.

{
  return _has_active_elemental_moose_variables[tid];
}

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

◆ hasActiveMaterialProperties()

bool FEProblemBase::hasActiveMaterialProperties ( const THREAD_ID tid ) const

Method to check whether or not a list of active material roperties has been set.

This method is called by reinitMaterials to determine whether Material computeProperties methods need to be called. If the return is False, this check prevents unnecessary material property computation

Parameters

tid	The thread id

Returns: True if there has been a list of active material properties set, False otherwise

Definition at line 6767 of file FEProblemBase.C.

{
  return _has_active_material_properties[tid];
}

Referenced by ComputeMarkerThread::onElement(), reinitMaterials(), reinitMaterialsBoundary(), reinitMaterialsFace(), reinitMaterialsFaceOnBoundary(), reinitMaterialsInterface(), reinitMaterialsNeighbor(), and reinitMaterialsNeighborOnBoundary().

◆ hasAuxiliaryVariable()

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

virtualinherited

Whether or not this problem has this auxiliary variable.

Definition at line 803 of file SubProblem.C.

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

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

◆ hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

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

Definition at line 142 of file MooseBase.h.

142{ return _pars.hasBase(); }

InputParameters::hasBase

bool hasBase() const

Definition InputParameters.C:499

◆ hasBlockMaterialProperty()

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

virtualinherited

Check if a material property is defined on a block.

Definition at line 503 of file SubProblem.C.

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

◆ hasBoundaryMaterialProperty()

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

virtualinherited

Check if a material property is defined on a block.

Definition at line 562 of file SubProblem.C.

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

◆ hasConvergence()

bool FEProblemBase::hasConvergence	(	const std::string &	name,
		const THREAD_ID	tid = `0`
	)		const

virtual

Returns true if the problem has a Convergence object of the given name.

Definition at line 2848 of file FEProblemBase.C.

{
  return _convergences.hasActiveObject(name, tid);
}

Referenced by ParsedConvergence::initializeSymbols().

◆ hasDampers()

bool FEProblemBase::hasDampers ( )

inline

Whether or not this system has dampers.

Definition at line 1676 of file FEProblemBase.h.

1676{ return _has_dampers; }

Referenced by NonlinearSystemBase::preInit(), and NonlinearSystem::solve().

◆ hasDistribution()

bool FEProblemBase::hasDistribution ( const std::string & name ) const

virtual

Definition at line 2924 of file FEProblemBase.C.

{
  std::vector<Distribution *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>("Distribution")
      .condition<AttribName>(name)
      .queryInto(objs);
  return !objs.empty();
}

◆ hasException()

virtual bool FEProblemBase::hasException ( )

inlinevirtual

Whether or not an exception has occurred.

Definition at line 535 of file FEProblemBase.h.

535{ return _has_exception; }

Referenced by NonlinearSystem::converged(), ThreadedNodeLoop< RangeType, IteratorType >::keepGoing(), and ThreadedElementLoop< RangeType >::keepGoing().

◆ hasFunction()

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

virtual

Definition at line 2790 of file FEProblemBase.C.

{
  return _functions.hasActiveObject(name, tid);
}

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), FunctorIC::FunctorIC(), getFunction(), FunctionInterface::hasFunctionByName(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), ParsedConvergence::initializeSymbols(), and MooseParsedFunction::initialSetup().

◆ hasFunctor()

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

inherited

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

Definition at line 1275 of file SubProblem.C.

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

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

◆ hasFunctorWithType()

template<typename T >

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

inherited

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

Definition at line 1316 of file SubProblem.h.

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

◆ hasFVGradientMethod()

bool FEProblemBase::hasFVGradientMethod ( const GradientMethodName & name ) const

Check if an FV gradient method with a given name exists.

Definition at line 4887 of file FEProblemBase.C.

{
  std::vector<FVGradientMethod *> methods;
  theWarehouse()
      .query()
      .condition<AttribSystem>("FVGradientMethod")
      .condition<AttribThread>(0)
      .condition<AttribName>(name)
      .queryInto(methods);
  return !methods.empty();
}

◆ hasFVInterpolationMethod()

bool FEProblemBase::hasFVInterpolationMethod ( const InterpolationMethodName & name ) const

Check if an FV interpolation method with a given name exists.

Definition at line 4961 of file FEProblemBase.C.

{
  std::vector<FVInterpolationMethod *> methods;
  theWarehouse()
      .query()
      .condition<AttribSystem>("FVInterpolationMethod")
      .condition<AttribThread>(0)
      .condition<AttribName>(name)
      .queryInto(methods);
  return !methods.empty();
}

Referenced by FVInterpolationMethodInterface::hasFVInterpolationMethod().

◆ hasInitialAdaptivity() [1/2]

bool FEProblemBase::hasInitialAdaptivity ( ) const

inline

Return a Boolean indicating whether initial AMR is turned on.

Definition at line 2194 of file FEProblemBase.h.

2194{ return _adaptivity.getInitialSteps() > 0; }

Adaptivity::getInitialSteps

unsigned int getInitialSteps() const

Pull out the number of initial steps previously set by calling init()

Definition Adaptivity.h:112

◆ hasInitialAdaptivity() [2/2]

bool FEProblemBase::hasInitialAdaptivity ( ) const

inline

Return a Boolean indicating whether initial AMR is turned on.

Definition at line 2199 of file FEProblemBase.h.

2199{ return false; }

◆ hasJacobian()

bool FEProblemBase::hasJacobian ( ) const

Returns _has_jacobian.

Definition at line 9859 of file FEProblemBase.C.

{
  return _has_jacobian;
}

Referenced by DisplacedProblem::prepare().

◆ hasKokkosFunction()

virtual bool FEProblemBase::hasKokkosFunction ( const std::string & name ) const

virtual

Get whether a Kokkos function exists.

Parameters

name	The Kokkos function name

Returns: Whether a Kokkos function exists

Referenced by getKokkosFunction().

◆ hasKokkosObjects()

bool FEProblemBase::hasKokkosObjects ( ) const

inline

Returns: whether any Kokkos object was added in the problem

Definition at line 3078 of file FEProblemBase.h.

3078{ return _has_kokkos_objects; }

FEProblemBase::_has_kokkos_objects

bool _has_kokkos_objects

Whether we have any Kokkos objects.

Definition FEProblemBase.h:3754

Referenced by MooseMesh::update().

◆ hasKokkosResidualObjects()

bool FEProblemBase::hasKokkosResidualObjects ( ) const

inline

Returns: whether any Kokkos residual object was added in the problem

Definition at line 3082 of file FEProblemBase.h.

3082{ return _has_kokkos_residual_objects; }

FEProblemBase::_has_kokkos_residual_objects

bool _has_kokkos_residual_objects

Whether we have any Kokkos residual objects.

Definition FEProblemBase.h:3757

Referenced by NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystem::computeScalingJacobian(), LinearSystem::preInit(), and NonlinearSystemBase::preInit().

◆ hasKokkosUserObject()

bool FEProblemBase::hasKokkosUserObject ( const std::string & name ) const

Check if there if a Kokkos user object of given name.

Parameters

name	The name of the Kokkos user object being checked for

Returns: true if the Kokkos user object exists, false otherwise

Referenced by checkUserObjectNameCollision(), UserObjectInterface::getUserObjectFromFEProblem(), and UserObjectInterface::hasUserObjectByName().

◆ hasLinearConvergenceObjects()

bool FEProblemBase::hasLinearConvergenceObjects ( ) const

Whether we have linear convergence objects.

Definition at line 10193 of file FEProblemBase.C.

{
  // If false,this means we have not set one, not that we are querying this too early
  // TODO: once there is a default linear CV object, error on the 'not set' case
  return _linear_convergence_names.has_value();
}

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

◆ hasLinearVariable()

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

virtualinherited

Whether or not this problem has this linear variable.

Definition at line 794 of file SubProblem.C.

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

Referenced by SubProblem::getFunctor().

◆ hasMortarCoupling()

virtual bool FEProblemBase::hasMortarCoupling ( ) const

inlinevirtual

Whether the simulation has mortar coupling.

Definition at line 2767 of file FEProblemBase.h.

2767{ return _has_mortar; }

◆ hasMultiApp()

bool FEProblemBase::hasMultiApp ( const std::string & name ) const

Definition at line 5970 of file FEProblemBase.C.

{
  return _multi_apps.hasActiveObject(multi_app_name);
}

Referenced by getMultiApp().

◆ hasMultiApps() [1/2]

bool FEProblemBase::hasMultiApps ( ) const

inline

Returns whether or not the current simulation has any multiapps.

Definition at line 1662 of file FEProblemBase.h.

1662{ return _multi_apps.hasActiveObjects(); }

Referenced by DefaultMultiAppFixedPointConvergence::checkConvergence(), checkProblemIntegrity(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), FixedPointIterationAdaptiveDT::init(), and DefaultMultiAppFixedPointConvergence::preIteration().

◆ hasMultiApps() [2/2]

bool FEProblemBase::hasMultiApps ( ExecFlagType type ) const

Definition at line 5964 of file FEProblemBase.C.

{
  return _multi_apps[type].hasActiveObjects();
}

◆ hasNeighborCoupling()

virtual bool FEProblemBase::hasNeighborCoupling ( ) const

inlinevirtual

Whether the simulation has neighbor coupling.

Definition at line 2762 of file FEProblemBase.h.

2762{ return _has_internal_edge_residual_objects; }

◆ hasNonlocalCoupling()

virtual bool FEProblemBase::hasNonlocalCoupling ( ) const

inlineoverridevirtual

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

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

Implements SubProblem.

Definition at line 3033 of file FEProblemBase.h.

3033{ return _has_nonlocal_coupling; }

Referenced by DisplacedProblem::hasNonlocalCoupling().

◆ hasPostprocessor()

bool FEProblemBase::hasPostprocessor ( const std::string & name ) const

Deprecated.

Use hasPostprocessorValueByName

Definition at line 5016 of file FEProblemBase.C.

{
  mooseDeprecated("FEProblemBase::hasPostprocssor is being removed; use "
                  "hasPostprocessorValueByName instead.");
  return hasPostprocessorValueByName(name);
}

Referenced by GenericFunctorTimeDerivativeMaterialTempl< is_ad >::GenericFunctorTimeDerivativeMaterialTempl().

◆ hasPostprocessorValueByName()

bool FEProblemBase::hasPostprocessorValueByName ( const PostprocessorName & name ) const

Whether or not a Postprocessor value exists by a given name.

Parameters

name	The name of the Postprocessor

Returns: True if a Postprocessor value exists

Note: You should prioritize the use of PostprocessorInterface::hasPostprocessor and PostprocessorInterface::hasPostprocessorByName over this method when possible.

Definition at line 4974 of file FEProblemBase.C.

{
  return _reporter_data.hasReporterValue<PostprocessorValue>(PostprocessorReporterName(name));
}

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), FunctorExtremaPositions::FunctorExtremaPositions(), hasPostprocessor(), MooseParsedFunction::initialSetup(), and FunctorIC::value().

◆ hasScalarVariable()

bool FEProblemBase::hasScalarVariable ( const std::string & var_name ) const

overridevirtual

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

Implements SubProblem.

Definition at line 6617 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    if (sys->hasScalarVariable(var_name))
      return true;
  if (_aux->hasScalarVariable(var_name))
    return true;
 
  return false;
}

Referenced by addInitialCondition(), addObjectParamsHelper(), EigenProblem::adjustEigenVector(), checkDuplicatePostprocessorVariableNames(), AdvancedOutput::initAvailableLists(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), MooseParsedFunction::initialSetup(), AdvancedOutput::initShowHideLists(), and Split::setup().

◆ hasSetMultiAppFixedPointConvergenceName()

bool FEProblemBase::hasSetMultiAppFixedPointConvergenceName ( ) const

inline

Returns true if the problem has set the fixed point convergence name.

Definition at line 793 of file FEProblemBase.h.

  {
    return _multiapp_fixed_point_convergence_name.has_value();
  }

◆ hasSetSteadyStateConvergenceName()

bool FEProblemBase::hasSetSteadyStateConvergenceName ( ) const

inline

Returns true if the problem has set the steady-state detection convergence name.

Definition at line 798 of file FEProblemBase.h.

  {
    return _steady_state_convergence_name.has_value();
  }

◆ hasSolutionState()

bool FEProblemBase::hasSolutionState	(	unsigned int	state,
		Moose::SolutionIterationType	iteration_type
	)		const

Whether we need up to old (1) or older (2) solution states for a given type of iteration.

Parameters

oldest_needed	oldest solution state needed
iteration_type	the type of iteration for which old/older states are needed

Definition at line 812 of file FEProblemBase.C.

{
  bool has_solution_state = false;
  for (auto & sys : _solver_systems)
    has_solution_state |= sys->hasSolutionState(state, iteration_type);
  has_solution_state |= _aux->hasSolutionState(state, iteration_type);
  return has_solution_state;
}

◆ hasSolverVariable()

bool FEProblemBase::hasSolverVariable ( const std::string & var_name ) const

Definition at line 6549 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    if (sys->hasVariable(var_name))
      return true;
 
  return false;
}

Referenced by FunctorChangeFunctorMaterialTempl< is_ad >::FunctorChangeFunctorMaterialTempl().

◆ hasTimeIntegrator()

bool FEProblemBase::hasTimeIntegrator ( ) const

inline

Returns whether or not this Problem has a TimeIntegrator.

Definition at line 2491 of file FEProblemBase.h.

2491{ return _has_time_integrator; }

Referenced by TransientBase::setupTimeIntegrator().

◆ hasUOAuxStateCheck()

bool FEProblemBase::hasUOAuxStateCheck ( ) const

inline

Whether or not MOOSE will perform a user object/auxiliary kernel state check.

Definition at line 221 of file FEProblemBase.h.

221{ return _uo_aux_state_check; }

◆ hasUserObject()

bool FEProblemBase::hasUserObject ( const std::string & name ) const

Check if there if a user object of given name.

Parameters

name	The name of the user object being checked for

Returns: true if the user object exists, false otherwise

Definition at line 4849 of file FEProblemBase.C.

{
  std::vector<UserObject *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>("UserObject")
      .condition<AttribThread>(0)
      .condition<AttribName>(name)
      .queryInto(objs);
  return !objs.empty();
}

Referenced by checkUserObjectNameCollision(), DistributedPositions::DistributedPositions(), MultiAppGeneralFieldFunctorTransfer::execute(), UserObjectInterface::getUserObjectFromFEProblem(), UserObjectInterface::hasUserObjectByName(), ReporterTransferInterface::hideVariableHelper(), ParsedDownSelectionPositions::initialize(), and TransformedPositions::TransformedPositions().

◆ hasVariable()

bool FEProblemBase::hasVariable ( const std::string & var_name ) const

overridevirtual

Whether or not this problem has the variable.

Implements SubProblem.

Definition at line 6537 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    if (sys->hasVariable(var_name))
      return true;
  if (_aux->hasVariable(var_name))
    return true;
 
  return false;
}

Referenced by addFVInitialCondition(), addInitialCondition(), addObjectParamsHelper(), MultiAppTransfer::checkVariable(), FunctorIC::FunctorIC(), LazyCoupleable::init(), AdvancedOutput::initAvailableLists(), MooseParsedFunction::initialSetup(), AdvancedOutput::initShowHideLists(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), and Split::setup().

◆ haveADObjects() [1/3]

bool SubProblem::haveADObjects ( ) const

inline

Method for reading wehther we have any ad objects.

Definition at line 782 of file SubProblem.h.

782{ return _have_ad_objects; }

SubProblem::_have_ad_objects

bool _have_ad_objects

AD flag indicating whether any AD objects have been added.

Definition SubProblem.h:1115

Referenced by computeJacobianTags(), computeResidualAndJacobian(), and init().

◆ haveADObjects() [2/3]

virtual void SubProblem::haveADObjects ( bool have_ad_objects )

inlinevirtual

Method for setting whether we have any ad objects.

Reimplemented from SubProblem.

Definition at line 778 of file SubProblem.h.

778{ _have_ad_objects = have_ad_objects; }

◆ haveADObjects() [3/3]

void FEProblemBase::haveADObjects ( bool have_ad_objects )

overridevirtual

Method for setting whether we have any ad objects.

Reimplemented from SubProblem.

Definition at line 9927 of file FEProblemBase.C.

{
  _have_ad_objects = have_ad_objects;
  if (_displaced_problem)
    _displaced_problem->SubProblem::haveADObjects(have_ad_objects);
}

◆ haveDisplaced()

bool FEProblemBase::haveDisplaced ( ) const

inlinefinaloverridevirtual

Whether we have a displaced problem in our simulation.

Implements SubProblem.

Definition at line 2867 of file FEProblemBase.h.

2867{ return _displaced_problem.get(); }

◆ haveFV()

virtual bool FEProblemBase::haveFV ( ) const

inlineoverridevirtual

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

Implements SubProblem.

Definition at line 3031 of file FEProblemBase.h.

3031{ return _have_fv; }

FEProblemBase::_have_fv

bool _have_fv

Whether we are performing some calculations with finite volume discretizations.

Definition FEProblemBase.h:3740

Referenced by NonlinearSystemBase::checkKernelCoverage(), NonlinearSystemBase::computeJacobianInternal(), NonlinearThread::computeOnElement(), ComputeFullJacobianThread::computeOnElement(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::customSetup(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), ComputeResidualThread::determineObjectWarehouses(), DisplacedProblem::haveFV(), init(), NonlinearSystemBase::initialSetup(), meshChanged(), projectSolution(), swapBackMaterialsNeighbor(), and NonlinearSystemBase::timestepSetup().

◆ haveXFEM()

bool FEProblemBase::haveXFEM ( )

inline

Find out whether the current analysis is using XFEM.

Definition at line 2209 of file FEProblemBase.h.

2209{ return _xfem != nullptr; }

Referenced by FixedPointSolve::solveStep(), TransientBase::takeStep(), and updateMeshXFEM().

◆ identifyVariableGroupsInNL()

bool FEProblemBase::identifyVariableGroupsInNL ( ) const

inline

Whether to identify variable groups in nonlinear systems.

This affects dof ordering

Definition at line 3038 of file FEProblemBase.h.

3038{ return _identify_variable_groups_in_nl; }

Referenced by NonlinearSystemBase::NonlinearSystemBase().

◆ ignoreZerosInJacobian()

bool FEProblemBase::ignoreZerosInJacobian ( ) const

inline

Will return true if zeros in the Jacobian are to be dropped from the sparsity pattern.

Note that this can make preserving the matrix sparsity pattern impossible.

Definition at line 2463 of file FEProblemBase.h.

2463{ return _ignore_zeros_in_jacobian; }

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

◆ immediatelyPrintInvalidSolution()

bool FEProblemBase::immediatelyPrintInvalidSolution ( ) const

inline

Whether or not the solution invalid warnings are printed out immediately.

Definition at line 2488 of file FEProblemBase.h.

2488{ return _immediately_print_invalid_solution; }

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

◆ incrementMultiAppTStep()

void FEProblemBase::incrementMultiAppTStep ( ExecFlagType type )

Advance the MultiApps t_step (incrementStepOrReject) associated with the ExecFlagType.

Definition at line 6368 of file FEProblemBase.C.

{
  const auto & multi_apps = _multi_apps[type].getActiveObjects();
 
  if (multi_apps.size())
    for (const auto & multi_app : multi_apps)
      multi_app->incrementTStep(_time);
}

Referenced by TransientBase::incrementStepOrReject().

◆ init()

void FEProblemBase::init ( )

overridevirtual

Implements Problem.

Reimplemented in EigenProblem, and FEProblem.

Definition at line 7047 of file FEProblemBase.C.

{
  if (_initialized)
    return;
 
  TIME_SECTION("init", 2, "Initializing");
 
  // call executioner's preProblemInit so that it can do some setups before problem init
  _app.getExecutioner()->preProblemInit();
 
  // If we have AD and we are doing global AD indexing, then we should by default set the matrix
  // coupling to full. If the user has told us to trust their coupling matrix, then this call will
  // not do anything
  if (haveADObjects() && Moose::globalADIndexing())
    setCoupling(Moose::COUPLING_FULL);
 
  for (const auto i : index_range(_nl))
  {
    auto & nl = _nl[i];
    auto & cm = _cm[i];
 
    unsigned int n_vars = nl->nVariables();
    {
      TIME_SECTION("fillCouplingMatrix", 3, "Filling Coupling Matrix");
 
      switch (_coupling)
      {
        case Moose::COUPLING_DIAG:
          cm = std::make_unique<CouplingMatrix>(n_vars);
          for (unsigned int i = 0; i < n_vars; i++)
            (*cm)(i, i) = 1;
          break;
 
          // for full jacobian
        case Moose::COUPLING_FULL:
          cm = std::make_unique<CouplingMatrix>(n_vars);
          for (unsigned int i = 0; i < n_vars; i++)
            for (unsigned int j = 0; j < n_vars; j++)
              (*cm)(i, j) = 1;
          break;
 
        case Moose::COUPLING_CUSTOM:
          // do nothing, _cm was already set through couplingMatrix() call
          break;
      }
    }
 
    nl->dofMap()._dof_coupling = cm.get();
 
    // If there are no variables, make sure to pass a nullptr coupling
    // matrix, to avoid warnings about non-nullptr yet empty
    // CouplingMatrices.
    if (n_vars == 0)
      nl->dofMap()._dof_coupling = nullptr;
 
    nl->dofMap().attach_extra_sparsity_function(&extraSparsity, nl.get());
    nl->dofMap().attach_extra_send_list_function(&extraSendList, nl.get());
    _aux->dofMap().attach_extra_send_list_function(&extraSendList, _aux.get());
 
    if (!_skip_nl_system_check && _solve && n_vars == 0)
      mooseError("No variables specified in nonlinear system '", nl->name(), "'.");
  }
 
  ghostGhostedBoundaries(); // We do this again right here in case new boundaries have been added
 
  // We may have added element/nodes to the mesh in ghostGhostedBoundaries so we need to update
  // all of our mesh information. We need to make sure that mesh information is up-to-date before
  // EquationSystems::init because that will call through to updateGeomSearch (for sparsity
  // augmentation) and if we haven't added back boundary node information before that latter call,
  // then we're screwed. We'll get things like "Unable to find closest node!"
  _mesh.meshChanged();
  if (_displaced_problem)
    _displaced_mesh->meshChanged();
 
  if (_mesh.doingPRefinement())
  {
    preparePRefinement();
    if (_displaced_problem)
      _displaced_problem->preparePRefinement();
  }
 
  // do not assemble system matrix for JFNK solve
  for (auto & nl : _nl)
    if (solverParams(nl->number())._type == Moose::ST_JFNK)
      nl->turnOffJacobian();
 
  for (auto & sys : _solver_systems)
    sys->preInit();
  _aux->preInit();
 
  // Build the mortar segment meshes, if they haven't been already, for a couple reasons:
  // 1) Get the ghosting correct for both static and dynamic meshes
  // 2) Make sure the mortar mesh is built for mortar constraints that live on the static mesh
  //
  // It is worth-while to note that mortar meshes that live on a dynamic mesh will be built
  // during residual and Jacobian evaluation because when displacements are solution variables
  // the mortar mesh will move and change during the course of a non-linear solve. We DO NOT
  // redo ghosting during non-linear solve, so for purpose 1) the below call has to be made
  if (!_mortar_data->initialized())
    updateMortarMesh();
 
  {
    TIME_SECTION("EquationSystems::Init", 2, "Initializing Equation Systems");
    es().init();
  }
 
  for (auto & sys : _solver_systems)
    sys->postInit();
  _aux->postInit();
 
  // Now that the equation system and the dof distribution is done, we can generate the
  // finite volume-related parts if needed.
  if (haveFV())
    _mesh.setupFiniteVolumeMeshData();
 
  for (auto & sys : _solver_systems)
    sys->update();
  _aux->update();
 
  for (THREAD_ID tid = 0; tid < numThreads(); ++tid)
    for (const auto i : index_range(_nl))
    {
      mooseAssert(
          _cm[i],
          "Coupling matrix not set for system "
              << i
              << ". This should only happen if a preconditioner was not setup for this system");
      _assembly[tid][i]->init(_cm[i].get());
    }
 
  if (_displaced_problem)
    _displaced_problem->init();
 
#ifdef MOOSE_KOKKOS_ENABLED
  if (_has_kokkos_objects)
    initKokkos();
#endif
 
  _initialized = true;
}

Referenced by EigenProblem::init(), and FEProblem::init().

◆ initElementStatefulProps()

void FEProblemBase::initElementStatefulProps	(	const libMesh::ConstElemRange &	elem_range,
		const bool	threaded
	)

Initialize stateful properties for elements in a specific elem_range This is needed when elements/boundary nodes are added to a specific subdomain at an intermediate step.

Definition at line 9227 of file FEProblemBase.C.

{
  ComputeMaterialsObjectThread cmt(
      *this, _material_props, _bnd_material_props, _neighbor_material_props, _assembly);
  if (threaded)
    Threads::parallel_reduce(elem_range, cmt, numThreads());
  else
    cmt(elem_range, true);
 
#ifdef MOOSE_KOKKOS_ENABLED
  if (_has_kokkos_objects)
    initKokkosStatefulProps();
#endif
}

Referenced by ActivateElementsUserObjectBase::finalize(), and ElementSubdomainModifierBase::initElementStatefulProps().

◆ initialAdaptMesh()

void FEProblemBase::initialAdaptMesh ( )

virtual

Definition at line 8887 of file FEProblemBase.C.

{
  unsigned int n = adaptivity().getInitialSteps();
  _cycles_completed = 0;
  if (n)
  {
    if (!_mesh.interiorLowerDBlocks().empty() || !_mesh.boundaryLowerDBlocks().empty())
      mooseError("HFEM does not support mesh adaptivity currently.");
 
    TIME_SECTION("initialAdaptMesh", 2, "Performing Initial Adaptivity");
 
    for (unsigned int i = 0; i < n; i++)
    {
      computeIndicators();
      computeMarkers();
 
      if (_adaptivity.initialAdaptMesh())
      {
        meshChanged(
            /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
 
        // reproject the initial condition
        projectSolution();
 
        _cycles_completed++;
      }
      else
      {
        _console << "Mesh unchanged, skipping remaining steps..." << std::endl;
        return;
      }
    }
  }
}

◆ initialized()

bool FEProblemBase::initialized ( ) const

inline

Returns: Whether the problem was initialized, i.e. whether init() has executed

Definition at line 169 of file FEProblemBase.h.

169{ return _initialized; }

Referenced by MooseMesh::update().

◆ initialSetup()

void FEProblemBase::initialSetup ( )

overridevirtual

If this is a restart run, the user may want to override the start time, which we already set in the constructor. "_time" however will have been "restored" from the restart file. We need to honor the original request of the developer now that the restore has been completed.

If we are not recovering but we are doing restart (_app.getExodusFileRestart() == true) with additional uniform refinements. We have to delay the refinement until this point in time so that the equation systems are initialized and projections can be performed.

Reimplemented from SubProblem.

Reimplemented in MFEMProblem.

Definition at line 962 of file FEProblemBase.C.

{
  TIME_SECTION("initialSetup", 2, "Performing Initial Setup");
 
  SubProblem::initialSetup();
 
  if (_app.isRecovering() + _app.isRestarting() + bool(_app.getExReaderForRestart()) > 1)
    mooseError("Checkpoint recovery and restart and exodus restart are all mutually exclusive.");
 
  if (_skip_exception_check)
    mooseWarning("MOOSE may fail to catch an exception when the \"skip_exception_check\" parameter "
                 "is used. If you receive a terse MPI error during execution, remove this "
                 "parameter and rerun your simulation");
 
  // set state flag indicating that we are in or beyond initialSetup.
  // This can be used to throw errors in methods that _must_ be called at construction time.
  _started_initial_setup = true;
  setCurrentExecuteOnFlag(EXEC_INITIAL);
 
  // Setup the solution states (current, old, etc) in each system based on
  // its default and the states requested of each of its variables
  for (const auto i : index_range(_solver_systems))
  {
    _solver_systems[i]->initSolutionState();
    if (getDisplacedProblem())
      getDisplacedProblem()->solverSys(i).initSolutionState();
  }
  _aux->initSolutionState();
  if (getDisplacedProblem())
    getDisplacedProblem()->auxSys().initSolutionState();
 
  // always execute to get the max number of DoF per element and node needed to initialize phi_zero
  // variables
  dof_id_type global_max_var_n_dofs_per_elem = 0;
  for (const auto i : index_range(_solver_systems))
  {
    auto & sys = *_solver_systems[i];
    dof_id_type max_var_n_dofs_per_elem;
    dof_id_type max_var_n_dofs_per_node;
    {
      TIME_SECTION("computingMaxDofs", 3, "Computing Max Dofs Per Element");
 
      MaxVarNDofsPerElem mvndpe(*this, sys);
      Threads::parallel_reduce(getCurrentAlgebraicElementRange(), mvndpe, numThreads());
      max_var_n_dofs_per_elem = mvndpe.max();
      _communicator.max(max_var_n_dofs_per_elem);
 
      MaxVarNDofsPerNode mvndpn(*this, sys);
      Threads::parallel_reduce(getCurrentAlgebraicNodeRange(), mvndpn, numThreads());
      max_var_n_dofs_per_node = mvndpn.max();
      _communicator.max(max_var_n_dofs_per_node);
      global_max_var_n_dofs_per_elem =
          std::max(global_max_var_n_dofs_per_elem, max_var_n_dofs_per_elem);
    }
 
    {
      TIME_SECTION("assignMaxDofs", 5, "Assigning Maximum Dofs Per Elem");
 
      sys.assignMaxVarNDofsPerElem(max_var_n_dofs_per_elem);
      auto displaced_problem = getDisplacedProblem();
      if (displaced_problem)
        displaced_problem->solverSys(i).assignMaxVarNDofsPerElem(max_var_n_dofs_per_elem);
 
      sys.assignMaxVarNDofsPerNode(max_var_n_dofs_per_node);
      if (displaced_problem)
        displaced_problem->solverSys(i).assignMaxVarNDofsPerNode(max_var_n_dofs_per_node);
    }
  }
 
  {
    TIME_SECTION("resizingVarValues", 5, "Resizing Variable Values");
 
    for (unsigned int tid = 0; tid < numThreads(); ++tid)
    {
      _phi_zero[tid].resize(global_max_var_n_dofs_per_elem, std::vector<Real>(getMaxQps(), 0.));
      _grad_phi_zero[tid].resize(global_max_var_n_dofs_per_elem,
                                 std::vector<RealGradient>(getMaxQps(), RealGradient(0.)));
      _second_phi_zero[tid].resize(global_max_var_n_dofs_per_elem,
                                   std::vector<RealTensor>(getMaxQps(), RealTensor(0.)));
    }
  }
 
  // Set up stateful material property redistribution, if we suspect
  // it may be necessary later.
  addAnyRedistributers();
 
  if (_app.isRestarting() || _app.isRecovering() || _force_restart)
  {
    // Only load all of the vectors if we're recovering
    _req.set().setLoadAllVectors(_app.isRecovering());
 
    // This forces stateful material property loading to be an exact one-to-one match
    if (_app.isRecovering())
    {
      for (auto props : {&_material_props, &_bnd_material_props, &_neighbor_material_props})
        props->setRecovering();
 
#ifdef MOOSE_KOKKOS_ENABLED
      for (auto props :
           {&_kokkos_material_props, &_kokkos_bnd_material_props, &_kokkos_neighbor_material_props})
        props->setRecovering();
#endif
    }
 
    TIME_SECTION("restore", 3, "Restoring from backup");
 
    // We could have a cached backup when this app is a sub-app and has been given a Backup
    if (!_app.hasInitialBackup())
      _app.restore(_app.restartFolderBase(_app.getRestartRecoverFileBase()), _app.isRestarting());
    else
      _app.restoreFromInitialBackup(_app.isRestarting());
 
    if (_app.isRestarting())
    {
      if (_app.hasStartTime())
        _time = _time_old = _time_older = _app.getStartTime();
      else
      {
        _time_older = _time_old;
        _time_old = _time;
      }
    }
  }
  else
  {
    libMesh::ExodusII_IO * reader = _app.getExReaderForRestart();
 
    if (reader)
    {
      TIME_SECTION("copyingFromExodus", 3, "Copying Variables From Exodus");
 
      for (auto & sys : _solver_systems)
        sys->copyVars(*reader);
      _aux->copyVars(*reader);
    }
    else
    {
      if (_solver_systems[0]->hasVarCopy() || _aux->hasVarCopy())
        mooseError("Need Exodus reader to restart variables but the reader is not available\n"
                   "Use either FileMesh with an Exodus mesh file or FileMeshGenerator with an "
                   "Exodus mesh file and with use_for_exodus_restart equal to true");
    }
  }
 
  // Perform output related setups
  _app.getOutputWarehouse().initialSetup();
 
  // Flush all output to _console that occur during construction and initialization of objects
  _app.getOutputWarehouse().mooseConsole();
 
  // Build Refinement and Coarsening maps for stateful material projections if necessary
  if ((_adaptivity.isOn() || _num_grid_steps) &&
      (_material_props.hasStatefulProperties() || _bnd_material_props.hasStatefulProperties() ||
       _neighbor_material_props.hasStatefulProperties()))
  {
    if (_has_internal_edge_residual_objects)
      mooseError("Stateful neighbor material properties do not work with mesh adaptivity");
 
    _mesh.buildRefinementAndCoarseningMaps(_assembly[0][0].get());
  }
 
  if (!_app.isRecovering())
  {
    if (_mesh.uniformRefineLevel() > 0 && _app.getExodusFileRestart())
    {
      if (!_app.isUltimateMaster())
        mooseError(
            "Doing extra refinements when restarting is NOT supported for sub-apps of a MultiApp");
 
      adaptivity().uniformRefineWithProjection();
    }
  }
 
  unsigned int n_threads = numThreads();
 
  // Convergence initial setup
  {
    TIME_SECTION("convergenceInitialSetup", 5, "Initializing Convergence objects");
 
    for (THREAD_ID tid = 0; tid < n_threads; tid++)
      _convergences.initialSetup(tid);
  }
 
  // UserObject initialSetup
  std::set<std::string> depend_objects_ic = _ics.getDependObjects();
  std::set<std::string> depend_objects_aux = _aux->getDependObjects();
 
  std::map<int, std::vector<UserObjectBase *>> group_userobjs;
 
  // This replaces all prior updateDependObjects calls on the old user object warehouses.
  TheWarehouse::Query uo_query = theWarehouse().query().condition<AttribSystem>("UserObject");
  std::vector<UserObjectBase *> userobjs;
  uo_query.queryInto(userobjs);
  groupUserObjects(
      theWarehouse(), getAuxiliarySystem(), _app.getExecuteOnEnum(), userobjs, depend_objects_ic);
 
  for (auto obj : userobjs)
    group_userobjs[obj->getParam<int>("execution_order_group")].push_back(obj);
 
#ifdef MOOSE_KOKKOS_ENABLED
  {
    TheWarehouse::Query uo_query =
        theWarehouse().query().condition<AttribSystem>("KokkosUserObject");
    std::vector<UserObjectBase *> userobjs;
    uo_query.queryInto(userobjs);
    groupUserObjects(
        theWarehouse(), getAuxiliarySystem(), _app.getExecuteOnEnum(), userobjs, depend_objects_ic);
 
    for (auto obj : userobjs)
      group_userobjs[obj->getParam<int>("execution_order_group")].push_back(obj);
  }
#endif
 
  for (auto & [group, objs] : group_userobjs)
    for (auto obj : objs)
      obj->initialSetup();
 
  // check if jacobian calculation is done in userobject
  for (THREAD_ID tid = 0; tid < n_threads; ++tid)
    checkUserObjectJacobianRequirement(tid);
 
  // Check whether nonlocal coupling is required or not
  checkNonlocalCoupling();
  if (_requires_nonlocal_coupling)
    setVariableAllDoFMap(_uo_jacobian_moose_vars[0]);
 
  {
    TIME_SECTION("initializingFunctions", 5, "Initializing Functions");
 
    // Call the initialSetup methods for functions
    for (THREAD_ID tid = 0; tid < n_threads; tid++)
    {
      reinitScalars(tid); // initialize scalars so they are properly sized for use as input into
                          // ParsedFunctions
      _functions.initialSetup(tid);
    }
 
#ifdef MOOSE_KOKKOS_ENABLED
    _kokkos_functions.initialSetup();
#endif
  }
 
  {
    TIME_SECTION("initializingRandomObjects", 5, "Initializing Random Objects");
 
    // Random interface objects
    for (const auto & it : _random_data_objects)
      it.second->updateSeeds(EXEC_INITIAL);
  }
 
  if (!_app.isRecovering())
  {
    computeUserObjects(EXEC_INITIAL, Moose::PRE_IC);
 
    {
      TIME_SECTION("ICinitialSetup", 5, "Setting Up Initial Conditions");
 
      for (THREAD_ID tid = 0; tid < n_threads; tid++)
      {
        _ics.initialSetup(tid);
        _fv_ics.initialSetup(tid);
      }
 
      _scalar_ics.initialSetup();
    }
 
    projectSolution();
  }
 
  // Materials
  if (_all_materials.hasActiveObjects(0))
  {
    TIME_SECTION("materialInitialSetup", 3, "Setting Up Materials");
 
    for (THREAD_ID tid = 0; tid < n_threads; tid++)
    {
      // Sort the Material objects, these will be actually computed by MOOSE in reinit methods.
      _materials.sort(tid);
      _interface_materials.sort(tid);
 
      // Call initialSetup on all material objects
      _all_materials.initialSetup(tid);
 
      // Discrete materials may insert additional dependencies on materials during the initial
      // setup. Therefore we resolve the dependencies once more, now with the additional
      // dependencies due to discrete materials.
      if (_discrete_materials.hasActiveObjects())
      {
        _materials.sort(tid);
        _interface_materials.sort(tid);
      }
    }
 
#ifdef MOOSE_KOKKOS_ENABLED
    _kokkos_materials.sort(0, true);
#endif
 
    {
      TIME_SECTION("computingInitialStatefulProps", 3, "Computing Initial Material Values");
 
      initElementStatefulProps(getCurrentAlgebraicElementRange(), true);
 
      if (_material_props.hasStatefulProperties() || _bnd_material_props.hasStatefulProperties() ||
          _neighbor_material_props.hasStatefulProperties())
        _has_initialized_stateful = true;
#ifdef MOOSE_KOKKOS_ENABLED
      if (_kokkos_material_props.hasStatefulProperties() ||
          _kokkos_bnd_material_props.hasStatefulProperties() ||
          _kokkos_neighbor_material_props.hasStatefulProperties())
        _has_initialized_stateful = true;
#endif
    }
  }
 
  // setRestartInPlace() is set because the property maps have now been setup and we can
  // dataLoad() them directly in place
  // setRecovering() is set because from now on we require a one-to-one mapping of
  // stateful properties because we shouldn't be declaring any more
  for (auto props : {&_material_props, &_bnd_material_props, &_neighbor_material_props})
  {
    props->setRestartInPlace();
    props->setRecovering();
  }
 
  for (THREAD_ID tid = 0; tid < n_threads; tid++)
  {
    _internal_side_indicators.initialSetup(tid);
    _indicators.initialSetup(tid);
    _markers.sort(tid);
    _markers.initialSetup(tid);
  }
 
#ifdef LIBMESH_ENABLE_AMR
 
  if (!_app.isRecovering() && !_app.restoredInitialBackupMesh())
  {
    unsigned int n = adaptivity().getInitialSteps();
    if (n && !_app.isUltimateMaster() && _app.isRestarting())
      mooseError("Cannot perform initial adaptivity during restart on sub-apps of a MultiApp!");
 
    initialAdaptMesh();
  }
 
#endif // LIBMESH_ENABLE_AMR
 
  if (!_app.isRecovering() && !_app.isRestarting())
  {
    // During initial setup the solution is copied to the older solution states (old, older, etc)
    copySolutionsBackwards();
 
    // Check if there are old state initial conditions
    auto ics = _ics.getActiveObjects();
    auto fv_ics = _fv_ics.getActiveObjects();
    auto scalar_ics = _scalar_ics.getActiveObjects();
    unsigned short ic_state_max = 0;
 
    auto findMax = [&ic_state_max](const auto & obj_list)
    {
      for (auto ic : obj_list.getActiveObjects())
        ic_state_max = std::max(ic_state_max, ic->getState());
    };
    findMax(_ics);
    findMax(_fv_ics);
    findMax(_scalar_ics);
 
    // if there are old state ICs, compute them and write to old states accordingly
    if (ic_state_max > 0)
    {
      // state 0 copy (we'll overwrite current state when evaluating ICs and need to restore it once
      // we're done with the old/older state ICs)
      std::vector<std::unique_ptr<NumericVector<Real>>> state0_sys_buffers(_solver_systems.size());
      std::unique_ptr<NumericVector<Real>> state0_aux_buffer;
 
      // save state 0
      for (const auto i : index_range(_solver_systems))
        state0_sys_buffers[i] = _solver_systems[i]->solutionState(0).clone();
 
      state0_aux_buffer = _aux->solutionState(0).clone();
 
      // compute old state ICs
      for (_current_ic_state = 1; _current_ic_state <= ic_state_max; _current_ic_state++)
      {
        projectSolution();
 
        for (auto & sys : _solver_systems)
          sys->solutionState(_current_ic_state) = sys->solutionState(0);
 
        _aux->solutionState(_current_ic_state) = _aux->solutionState(0);
      }
      _current_ic_state = 0;
 
      // recover state 0
      for (const auto i : index_range(_solver_systems))
      {
        _solver_systems[i]->solutionState(0) = *state0_sys_buffers[i];
        _solver_systems[i]->solutionState(0).close();
        _solver_systems[i]->update();
      }
      _aux->solutionState(0) = *state0_aux_buffer;
      _aux->solutionState(0).close();
      _aux->update();
    }
  }
 
  if (!_app.isRecovering())
  {
    if (haveXFEM())
      updateMeshXFEM();
  }
 
  // Call initialSetup on the solver systems
  for (auto & sys : _solver_systems)
    sys->initialSetup();
 
  // Auxilary variable initialSetup calls
  _aux->initialSetup();
 
  if (_displaced_problem)
    // initialSetup for displaced systems
    _displaced_problem->initialSetup();
 
  for (auto & sys : _solver_systems)
    sys->setSolution(*(sys->system().current_local_solution.get()));
 
  // Update the nearest node searches (has to be called after the problem is all set up)
  // We do this here because this sets up the Element's DoFs to ghost
  updateGeomSearch(GeometricSearchData::NEAREST_NODE);
 
  _mesh.updateActiveSemiLocalNodeRange(_ghosted_elems);
  if (_displaced_mesh)
    _displaced_mesh->updateActiveSemiLocalNodeRange(_ghosted_elems);
 
  // We need to move the mesh in order to build a map between mortar secondary and primary
  // interfaces. This map will then be used by the AgumentSparsityOnInterface ghosting functor to
  // know which dofs we need ghosted when we call EquationSystems::reinit
  if (_displaced_problem && _mortar_data->hasDisplacedObjects())
  {
    _displaced_problem->updateMesh();
    // if displacements were applied to the mesh, the mortar mesh should be updated too
    updateMortarMesh();
  }
 
  // Possibly reinit one more time to get ghosting correct
  reinitBecauseOfGhostingOrNewGeomObjects();
 
  if (_displaced_mesh)
    _displaced_problem->updateMesh();
 
  updateGeomSearch(); // Call all of the rest of the geometric searches
 
  for (auto & sys : _solver_systems)
  {
    const auto & tis = sys->getTimeIntegrators();
 
    {
      TIME_SECTION("timeIntegratorInitialSetup", 5, "Initializing Time Integrator");
      for (auto & ti : tis)
        ti->initialSetup();
    }
  }
 
  // HUGE NOTE: MultiApp initialSetup() MUST... I repeat MUST be _after_ main-app restartable data
  // has been restored
 
  // Call initialSetup on the MultiApps
  if (_multi_apps.hasObjects())
  {
    TIME_SECTION("initialSetupMultiApps", 2, "Initializing MultiApps", false);
    // Assign concurrent multiapps their disjoint rank partitions before the sub-apps are created
    // so that each is created on the communicator it will actually run on
    partitionConcurrentMultiApps();
    _multi_apps.initialSetup();
  }
 
  // Call initialSetup on the transfers
  {
    TIME_SECTION("initialSetupTransfers", 2, "Initializing Transfers");
 
    _transfers.initialSetup();
 
    // Call initialSetup on the MultiAppTransfers to be executed on TO_MULTIAPP
    const auto & to_multi_app_objects = _to_multi_app_transfers.getActiveObjects();
    for (const auto & transfer : to_multi_app_objects)
    {
      transfer->setCurrentDirection(Transfer::DIRECTION::TO_MULTIAPP);
      transfer->initialSetup();
    }
 
    // Call initialSetup on the MultiAppTransfers to be executed on FROM_MULTIAPP
    const auto & from_multi_app_objects = _from_multi_app_transfers.getActiveObjects();
    for (const auto & transfer : from_multi_app_objects)
    {
      transfer->setCurrentDirection(Transfer::DIRECTION::FROM_MULTIAPP);
      transfer->initialSetup();
    }
 
    // Call initialSetup on the MultiAppTransfers to be executed on BETWEEN_MULTIAPP
    const auto & between_multi_app_objects = _between_multi_app_transfers.getActiveObjects();
    for (const auto & transfer : between_multi_app_objects)
    {
      transfer->setCurrentDirection(Transfer::DIRECTION::BETWEEN_MULTIAPP);
      transfer->initialSetup();
    }
  }
 
  if (_boundary_restricted_node_integrity_check)
  {
    TIME_SECTION("BoundaryRestrictedNodeIntegrityCheck", 5);
 
    // check that variables are defined along boundaries of boundary restricted nodal objects
    const auto & bnd_nodes = getCurrentAlgebraicBndNodeRange();
    BoundaryNodeIntegrityCheckThread bnict(*this, uo_query);
    Threads::parallel_reduce(bnd_nodes, bnict, numThreads());
 
    // Nodal bcs aren't threaded
    for (auto & nl : _nl)
    {
      const auto & nodal_bcs = nl->getNodalBCWarehouse();
      if (!nodal_bcs.hasBoundaryObjects())
        continue;
 
      for (const auto & bnode : bnd_nodes)
      {
        const auto boundary_id = bnode->_bnd_id;
        const Node * const node = bnode->_node;
 
        if (node->processor_id() != this->processor_id())
          continue;
 
        const auto & bnd_name = _mesh.getBoundaryName(boundary_id);
 
        // Avoid assertion in getBoundaryObjects that we have boundary objects for this boundary ID
        if (!nodal_bcs.hasBoundaryObjects(boundary_id))
          continue;
 
        const auto & bnd_objects = nodal_bcs.getBoundaryObjects(boundary_id);
        for (const auto & bnd_object : bnd_objects)
        {
          const auto & bnd_variable = bnd_object->variable();
          // Skip if this object uses geometric search because coupled variables may be defined on
          // paired boundaries instead of the boundary this node is on. Also skip if this boundary
          // condition isn't applicable to the current node, e.g. if the node doesn't have any
          // degrees of freedom for the boundary condition's variable
          if (!bnd_object->requiresGeometricSearch() &&
              bnd_object->checkVariableBoundaryIntegrity() &&
              node->n_dofs(nl->number(), bnd_variable.number()))
          {
            std::set<MooseVariableFieldBase *> vars_to_omit = {
                &cast_ref<MooseVariableFieldBase &>(const_cast<MooseVariableBase &>(bnd_variable))};
 
            boundaryIntegrityCheckError(
                *bnd_object, bnd_object->checkAllVariables(*node, vars_to_omit), bnd_name);
          }
        }
      }
    }
  }
 
  if (_boundary_restricted_elem_integrity_check)
  {
    TIME_SECTION("BoundaryRestrictedElemIntegrityCheck", 5);
 
    // check that variables are defined along boundaries of boundary restricted elemental objects
    ConstBndElemRange & bnd_elems = *mesh().getBoundaryElementRange();
    BoundaryElemIntegrityCheckThread beict(*this, uo_query);
    Threads::parallel_reduce(bnd_elems, beict, numThreads());
  }
 
  if (_fv_face_integrity_check)
  {
    TIME_SECTION("FVFaceIntegrityCheck", 5);
 
    auto check_fv_face_integrity = [this](MooseMesh & fv_mesh, const bool on_displaced)
    {
      auto flux_bc_base_query = theWarehouse()
                                    .query()
                                    .condition<AttribSystem>("FVFluxBC")
                                    .condition<AttribDisplaced>(on_displaced)
                                    .condition<AttribThread>(0);
      TheWarehouse::QueryCache<AttribBoundaries> flux_bc_query(flux_bc_base_query);
 
      auto interface_kernel_base_query = theWarehouse()
                                             .query()
                                             .condition<AttribSystem>("FVInterfaceKernel")
                                             .condition<AttribDisplaced>(on_displaced)
                                             .condition<AttribThread>(0);
      TheWarehouse::QueryCache<AttribBoundaries> interface_kernel_query(
          interface_kernel_base_query);
 
      std::vector<FVFluxBC *> flux_bcs;
      std::vector<FVInterfaceKernel *> interface_kernels;
 
      for (auto face_it = fv_mesh.ownedFaceInfoBegin(); face_it != fv_mesh.ownedFaceInfoEnd();
           ++face_it)
      {
        const FaceInfo & fi = **face_it;
 
        for (const auto boundary_id : fi.boundaryIDs())
        {
          auto boundary_key = std::make_tuple(boundary_id, false);
 
          flux_bc_query.queryInto(flux_bcs, boundary_key);
          for (const auto * const flux_bc : flux_bcs)
            if (flux_bc->checkVariableBoundaryIntegrity())
              flux_bc->checkFaceIntegrity(fi);
 
          interface_kernel_query.queryInto(interface_kernels, boundary_key);
          for (const auto * const interface_kernel : interface_kernels)
            interface_kernel->checkFaceIntegrity(fi);
        }
      }
    };
 
    if (haveFV())
      check_fv_face_integrity(mesh(), false);
 
    if (_displaced_problem && _displaced_problem->haveFV())
      check_fv_face_integrity(_displaced_problem->mesh(), true);
  }
 
  if (!_app.isRecovering())
  {
    bool converged = execMultiApps(EXEC_INITIAL);
    if (!converged)
      mooseError("failed to converge initial MultiApp");
 
    // We'll backup the Multiapp here
    backupMultiApps(EXEC_INITIAL);
 
    for (THREAD_ID tid = 0; tid < n_threads; tid++)
      reinitScalars(tid);
 
    execute(EXEC_INITIAL);
 
    // The FEProblemBase::execute method doesn't call all the systems on EXEC_INITIAL, but it does
    // set/unset the current flag. Therefore, this resets the current flag to EXEC_INITIAL so that
    // subsequent calls (e.g., executeControls) have the proper flag.
    setCurrentExecuteOnFlag(EXEC_INITIAL);
  }
 
  // Here we will initialize the stateful properties once more since they may have been updated
  // during initialSetup by calls to computeProperties.
  //
  // It's really bad that we don't allow this during restart.  It means that we can't add new
  // stateful materials
  // during restart.  This is only happening because this _has_ to be below initial userobject
  // execution.
  // Otherwise this could be done up above... _before_ restoring restartable data... which would
  // allow you to have
  // this happen during restart.  I honestly have no idea why this has to happen after initial user
  // object computation.
  // THAT is something we should fix... so I've opened this ticket: #5804
  if (!_app.isRecovering() && !_app.isRestarting())
  {
    if (_material_props.hasStatefulProperties() || _bnd_material_props.hasStatefulProperties() ||
        _neighbor_material_props.hasStatefulProperties())
    {
      TIME_SECTION("computeMaterials", 2, "Computing Initial Material Properties");
 
      initElementStatefulProps(getCurrentAlgebraicElementRange(), true);
    }
#ifdef MOOSE_KOKKOS_ENABLED
    if (_kokkos_material_props.hasStatefulProperties() ||
        _kokkos_bnd_material_props.hasStatefulProperties() ||
        _kokkos_neighbor_material_props.hasStatefulProperties())
    {
      TIME_SECTION("computeMaterials", 2, "Computing Initial Material Properties");
 
      initElementStatefulProps(getCurrentAlgebraicElementRange(), true);
    }
#endif
  }
 
  // Control Logic
  _control_warehouse.initialSetup();
  executeControls(EXEC_INITIAL);
 
  // Scalar variables need to reinited for the initial conditions to be available for output
  for (unsigned int tid = 0; tid < n_threads; tid++)
    reinitScalars(tid);
 
  if (_displaced_mesh)
    _displaced_problem->syncSolutions();
 
  // Writes all calls to _console from initialSetup() methods
  _app.getOutputWarehouse().mooseConsole();
 
  if (_requires_nonlocal_coupling)
  {
    setNonlocalCouplingMatrix();
    for (THREAD_ID tid = 0; tid < n_threads; ++tid)
      for (auto & assembly : _assembly[tid])
        assembly->initNonlocalCoupling();
  }
 
  {
    TIME_SECTION("lineSearchInitialSetup", 5, "Initializing Line Search");
 
    if (_line_search)
      _line_search->initialSetup();
  }
 
  // Perform Reporter get/declare check
  _reporter_data.check();
 
  // We do this late to allow objects to get late restartable data
  if (_app.isRestarting() || _app.isRecovering() || _force_restart)
    _app.finalizeRestore();
 
  setCurrentExecuteOnFlag(EXEC_NONE);
}

Referenced by EigenExecutionerBase::init(), Eigenvalue::init(), Steady::init(), TransientBase::init(), and MFEMProblem::initialSetup().

◆ initKokkos()

void FEProblemBase::initKokkos ( )

Construct Kokkos assembly and systems and allocate Kokkos material property storages.

Referenced by init().

◆ initKokkosStatefulProps()

void FEProblemBase::initKokkosStatefulProps ( )

Referenced by initElementStatefulProps().

◆ initNullSpaceVectors()

void FEProblemBase::initNullSpaceVectors	(	const InputParameters &	parameters,
		std::vector< std::shared_ptr< NonlinearSystemBase > > &	nl
	)

virtual

Definition at line 837 of file FEProblemBase.C.

{
  TIME_SECTION("initNullSpaceVectors", 5, "Initializing Null Space Vectors");
 
  unsigned int dimNullSpace = parameters.get<unsigned int>("null_space_dimension");
  unsigned int dimTransposeNullSpace =
      parameters.get<unsigned int>("transpose_null_space_dimension");
  unsigned int dimNearNullSpace = parameters.get<unsigned int>("near_null_space_dimension");
  for (unsigned int i = 0; i < dimNullSpace; ++i)
  {
    std::ostringstream oss;
    oss << "_" << i;
    // do not project, since this will be recomputed, but make it ghosted, since the near nullspace
    // builder might march over all nodes
    for (auto & nl : nls)
      nl->addVector("NullSpace" + oss.str(), false, libMesh::GHOSTED);
  }
  _subspace_dim["NullSpace"] = dimNullSpace;
  for (unsigned int i = 0; i < dimTransposeNullSpace; ++i)
  {
    std::ostringstream oss;
    oss << "_" << i;
    // do not project, since this will be recomputed, but make it ghosted, since the near nullspace
    // builder might march over all nodes
    for (auto & nl : nls)
      nl->addVector("TransposeNullSpace" + oss.str(), false, libMesh::GHOSTED);
  }
  _subspace_dim["TransposeNullSpace"] = dimTransposeNullSpace;
  for (unsigned int i = 0; i < dimNearNullSpace; ++i)
  {
    std::ostringstream oss;
    oss << "_" << i;
    // do not project, since this will be recomputed, but make it ghosted, since the near-nullspace
    // builder might march over all semilocal nodes
    for (auto & nl : nls)
      nl->addVector("NearNullSpace" + oss.str(), false, libMesh::GHOSTED);
  }
  _subspace_dim["NearNullSpace"] = dimNearNullSpace;
}

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

◆ initPetscOutputAndSomeSolverSettings()

void FEProblemBase::initPetscOutputAndSomeSolverSettings ( )

virtual

Reinitialize PETSc output for proper linear/nonlinear iteration display.

This also may be used for some PETSc-related solver settings

Reimplemented in EigenProblem.

Definition at line 7633 of file FEProblemBase.C.

{
  _app.getOutputWarehouse().solveSetup();
  Moose::PetscSupport::petscSetDefaults(*this);
}

Referenced by possiblyRebuildGeomSearchPatches(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), and solve().

◆ initXFEM()

void FEProblemBase::initXFEM ( std::shared_ptr< XFEMInterface > xfem )

Create XFEM controller object.

Definition at line 8985 of file FEProblemBase.C.

{
  _xfem = xfem;
  _xfem->setMesh(&_mesh);
  if (_displaced_mesh)
    _xfem->setDisplacedMesh(_displaced_mesh);
 
  auto fill_data = [this](auto & storage)
  {
    std::vector<MaterialData *> data(numThreads());
    for (const auto tid : make_range(numThreads()))
      data[tid] = &storage.getMaterialData(tid);
    return data;
  };
  _xfem->setMaterialData(fill_data(_material_props));
  _xfem->setBoundaryMaterialData(fill_data(_bnd_material_props));
 
  unsigned int n_threads = numThreads();
  for (unsigned int i = 0; i < n_threads; ++i)
    for (const auto nl_sys_num : index_range(_nl))
    {
      _assembly[i][nl_sys_num]->setXFEM(_xfem);
      if (_displaced_problem)
        _displaced_problem->assembly(i, nl_sys_num).setXFEM(_xfem);
    }
}

◆ isKokkosObject()

bool MooseObject::isKokkosObject ( ) const

inlineinherited

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

Definition at line 63 of file MooseObject.h.

63{ return parameters().isKokkosObject(); }

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

◆ isMatPropRequested()

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

virtualinherited

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

Definition at line 722 of file SubProblem.C.

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

◆ isParamSetByUser()

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

inlineinherited

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

Parameters

name	The name of the parameter to test

Definition at line 205 of file MooseBase.h.

  {
    return _pars.isParamSetByUser(name);
  }

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

◆ isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 199 of file MooseBase.h.

199{ return _pars.isParamValid(name); }

◆ isSNESMFReuseBaseSetbyUser()

bool FEProblemBase::isSNESMFReuseBaseSetbyUser ( )

inline

Return a flag to indicate if _snesmf_reuse_base is set by users.

Definition at line 2688 of file FEProblemBase.h.

2688{ return _snesmf_reuse_base_set_by_user; }

◆ isSolverSystemNonlinear()

bool FEProblemBase::isSolverSystemNonlinear ( const unsigned int sys_num )

inline

Check if the solver system is nonlinear.

Definition at line 2941 of file FEProblemBase.h.

2941{ return sys_num < _num_nl_sys; }

Referenced by addBoundaryCondition(), addConstraint(), addDamper(), addDGKernel(), addDiracKernel(), addHDGKernel(), addInterfaceKernel(), addKernel(), addScalarKernel(), and ConsoleUtils::outputExecutionInformation().

◆ isSolveTerminationRequested()

virtual bool Problem::isSolveTerminationRequested ( ) const

inlinevirtualinherited

Check of termination has been requested.

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

Definition at line 43 of file Problem.h.

43{ return _termination_requested; };

Problem::_termination_requested

bool _termination_requested

True if termination of the solve has been requested.

Definition Problem.h:58

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

◆ isTransient()

virtual bool FEProblemBase::isTransient ( ) const

inlineoverridevirtual

Implements SubProblem.

Definition at line 592 of file FEProblemBase.h.

592{ return _transient; }

Referenced by MFEMProblem::addVariable(), FixedPointSolve::autoAdvance(), checkExceptionAndStopSolve(), MFEMTimeDependentWeakFormProblemComposer::createProblemOperator(), PhysicsBase::isTransient(), DisplacedProblem::isTransient(), PIDTransientControl::PIDTransientControl(), PseudoTimestep::PseudoTimestep(), TimePeriodBase::TimePeriodBase(), Coupleable::validateExecutionerType(), and ScalarCoupleable::validateExecutionerType().

◆ jacobianSetup()

void FEProblemBase::jacobianSetup ( )

overridevirtual

Reimplemented from SubProblem.

Definition at line 10249 of file FEProblemBase.C.

{
  SubProblem::jacobianSetup();
  // We need to setup all the nonlinear systems other than our current one which actually called
  // this method (so we have to make sure we don't go in a circle)
  for (const auto i : make_range(numNonlinearSystems()))
    if (i != currentNlSysNum())
      _nl[i]->jacobianSetup();
  // We don't setup the aux sys because that's been done elsewhere
  if (_displaced_problem)
    _displaced_problem->jacobianSetup();
}

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

◆ joinAndFinalize()

void FEProblemBase::joinAndFinalize	(	TheWarehouse::Query	query,
		bool	isgen = `false`
	)

private

Definition at line 5332 of file FEProblemBase.C.

{
  std::vector<UserObject *> objs;
  query.queryInto(objs);
  if (!isgen)
  {
    // join all threaded user objects (i.e. not regular general user objects) to the primary
    // thread
    for (auto obj : objs)
      if (obj->primaryThreadCopy())
        obj->primaryThreadCopy()->threadJoin(*obj);
  }
 
  query.condition<AttribThread>(0).queryInto(objs);
 
  // finalize objects and retrieve/store any postprocessor values
  for (auto obj : objs)
  {
    if (isgen && dynamic_cast<ThreadedGeneralUserObject *>(obj))
      continue;
    if (isgen)
    {
      // general user objects are not run in their own threaded loop object - so run them here
      if (shouldPrintExecution(0))
        _console << "[DBG] Initializing, executing & finalizing general UO '" << obj->name()
                 << "' on " << _current_execute_on_flag.name() << std::endl;
      obj->initialize();
      obj->execute();
    }
 
    obj->finalize();
 
    // These have to be stored piecemeal (with every call to this function) because general
    // postprocessors (which run last after other userobjects have been completed) might depend on
    // them being stored.  This wouldn't be a problem if all userobjects satisfied the dependency
    // resolver interface and could be sorted appropriately with the general userobjects, but they
    // don't.
    auto pp = dynamic_cast<const Postprocessor *>(obj);
    if (pp)
    {
      _reporter_data.finalize(obj->name());
      setPostprocessorValueByName(obj->name(), pp->getValue());
    }
 
    auto vpp = dynamic_cast<VectorPostprocessor *>(obj);
    if (vpp)
      _reporter_data.finalize(obj->name());
 
    // Update Reporter data
    auto reporter = dynamic_cast<Reporter *>(obj);
    if (reporter)
      _reporter_data.finalize(obj->name());
  }
}

Referenced by computeUserObjectsInternal().

◆ kokkosAssembly() [1/2]

Moose::Kokkos::Assembly & FEProblemBase::kokkosAssembly ( )

inline

Definition at line 365 of file FEProblemBase.h.

365{ return _kokkos_assembly; }

◆ kokkosAssembly() [2/2]

const Moose::Kokkos::Assembly & FEProblemBase::kokkosAssembly ( ) const

inline

Definition at line 366 of file FEProblemBase.h.

366{ return _kokkos_assembly; }

◆ kokkosJoinAndFinalize()

void FEProblemBase::kokkosJoinAndFinalize ( const std::vector< Moose::Kokkos::UserObject * > & userobjs )

private

◆ linearSysNum()

unsigned int FEProblemBase::linearSysNum ( const LinearSystemName & linear_sys_name ) const

overridevirtual

Returns: the linear system number corresponding to the provided linear_sys_name

Implements SubProblem.

Definition at line 7200 of file FEProblemBase.C.

{
  std::istringstream ss(linear_sys_name);
  unsigned int linear_sys_num;
  if (!(ss >> linear_sys_num) || !ss.eof())
    linear_sys_num = libmesh_map_find(_linear_sys_name_to_num, linear_sys_name);
 
  return linear_sys_num;
}

Referenced by Moose::compute_linear_system(), computeLinearSystemSys(), LinearSystem::computeLinearSystemTags(), and DisplacedProblem::linearSysNum().

◆ lineSearch()

void FEProblemBase::lineSearch ( )

virtual

execute MOOSE line search

Definition at line 2894 of file FEProblemBase.C.

{
  _line_search->lineSearch();
}

Referenced by ComputeLineSearchObjectWrapper::linesearch().

◆ logAdd()

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

Output information about the object just added to the problem.

Definition at line 4585 of file FEProblemBase.C.

{
  if (_verbose_setup != "false")
    _console << "[DBG] Adding " << system << " '" << name << "' of type " << type << std::endl;
  if (_verbose_setup == "extra")
    _console << params << std::endl;
}

Referenced by addAuxArrayVariable(), addAuxScalarKernel(), addAuxScalarVariable(), addAuxVariable(), addConstraint(), addDamper(), addDGKernel(), addDiracKernel(), addFunction(), MFEMProblem::addFunction(), addFunctorMaterial(), addFVGradientMethod(), addFVInterpolationMethod(), addIndicator(), addInitialCondition(), addInterfaceKernel(), addMarker(), addMaterialHelper(), addMultiApp(), addNodalKernel(), addObject(), addOutput(), addPredictor(), addScalarKernel(), addTimeIntegrator(), addTransfer(), addUserObject(), addVariable(), setAuxKernelParamsAndLog(), and setResidualObjectParamsAndLog().

◆ makeLinearSolverParams()

SolverParams FEProblemBase::makeLinearSolverParams ( )

staticprivate

Make basic solver params for linear solves.

Definition at line 10476 of file FEProblemBase.C.

{
  SolverParams solver_params;
  solver_params._type = Moose::SolveType::ST_LINEAR;
  solver_params._line_search = Moose::LineSearchType::LS_NONE;
  return solver_params;
}

Referenced by FEProblemBase().

◆ markMatPropRequested()

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

virtualinherited

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

Definition at line 716 of file SubProblem.C.

{
  _material_property_requested.insert(prop_name);
}

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

◆ matrixTagExists() [1/2]

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

virtualinherited

Check to see if a particular Tag exists.

Reimplemented in DisplacedProblem.

Definition at line 320 of file SubProblem.C.

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

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

◆ matrixTagExists() [2/2]

bool SubProblem::matrixTagExists ( TagID tag_id ) const

virtualinherited

Check to see if a particular Tag exists.

Reimplemented in DisplacedProblem.

Definition at line 328 of file SubProblem.C.

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

◆ matrixTagName()

TagName SubProblem::matrixTagName ( TagID tag )

virtualinherited

Retrieve the name associated with a TagID.

Reimplemented in DisplacedProblem.

Definition at line 349 of file SubProblem.C.

{
  return _matrix_tag_id_to_tag_name[tag];
}

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

◆ mesh() [1/4]

virtual const MooseMesh & FEProblemBase::mesh ( ) const

inlineoverridevirtual

Implements SubProblem.

Reimplemented in MFEMProblem.

Definition at line 183 of file FEProblemBase.h.

183{ return _mesh; }

◆ mesh() [2/4]

virtual MooseMesh & FEProblemBase::mesh ( )

inlineoverridevirtual

Implements SubProblem.

Reimplemented in MFEMProblem.

Definition at line 182 of file FEProblemBase.h.

182{ return _mesh; }

Referenced by Adaptivity::adaptMesh(), addAnyRedistributers(), MultiAppConservativeTransfer::adjustTransferredSolution(), MultiAppConservativeTransfer::adjustTransferredSolutionNearestPoint(), PhysicsBasedPreconditioner::apply(), MultiAppGeneralFieldFunctorTransfer::buildKDTrees(), MultiAppGeneralFieldNearestLocationTransfer::buildKDTrees(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), SampledOutput::cloneMesh(), NonlinearSystemBase::computeJacobianInternal(), LinearSystem::computeLinearSystemInternal(), ComputeFullJacobianThread::computeOnInternalFace(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), coordTransform(), MultiApp::createApp(), DMMooseGetEmbedding_Private(), ElementsAlongLine::ElementsAlongLine(), ElementsAlongPlane::ElementsAlongPlane(), MultiAppUserObjectTransfer::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), MultiAppVariableValueSampleTransfer::execute(), ElementsAlongLine::execute(), ElementsAlongPlane::execute(), IntersectionPointsAlongLine::execute(), WorkBalance::execute(), MultiAppMFEMTolibMeshShapeEvaluationTransfer::extractlibMeshNodePositions(), CentroidMultiApp::fillPositions(), QuadraturePointMultiApp::fillPositions(), MultiAppGeometricInterpolationTransfer::fillSourceInterpolationPoints(), FunctionPeriodicBoundary::FunctionPeriodicBoundary(), MultiApp::getBoundingBox(), EqualValueBoundaryConstraint::ghostPrimary(), Exodus::handleExodusIOMeshRenumbering(), FunctorPositions::initialize(), ParsedDownSelectionPositions::initialize(), FunctorTimes::initialize(), BlockRestrictable::initializeBlockRestrictable(), BoundaryRestrictable::initializeBoundaryRestrictable(), ImageFunction::initialSetup(), PiecewiseConstantFromCSV::initialSetup(), MultiAppDofCopyTransfer::initialSetup(), SolutionUserObjectBase::initialSetup(), MultiAppGeometricInterpolationTransfer::interpolateTargetPoints(), IntersectionPointsAlongLine::IntersectionPointsAlongLine(), Moose::Mortar::loopOverMortarSegments(), ReporterPointMarker::markerSetup(), mesh(), mesh(), MultiAppGeometricInterpolationTransfer::MultiAppGeometricInterpolationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), BoundaryNodeIntegrityCheckThread::onNode(), ComputeNodalUserObjectsThread::onNode(), BoundaryElemIntegrityCheckThread::operator()(), ComputeLinearFVGreenGaussGradientVolumeThread::operator()(), ComputeLinearFVLimitedGradientThread::operator()(), ComputeInitialConditionThread::operator()(), Checkpoint::output(), Output::Output(), Exodus::outputEmptyTimestep(), ConsoleUtils::outputMeshInformation(), Exodus::outputNodalVariables(), Exodus::outputSetup(), Nemesis::outputSetup(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), MeshInfo::possiblyAddDomainInfo(), ComputeLinearFVElementalThread::printBlockExecutionInformation(), ComputeLinearFVFaceThread::printBlockExecutionInformation(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), MaterialPropertyDebugOutput::printMaterialMap(), TopResidualDebugOutput::printTopResiduals(), MultiAppMFEMTolibMeshShapeEvaluationTransfer::projectlibMeshNodalValues(), SolutionUserObjectBase::readExodusIIOrNemesis(), MooseApp::restore(), TransientMultiApp::setupApp(), Moose::PeriodicBCHelper::setupManualPeriodicBoundaries(), Moose::PeriodicBCHelper::setupPeriodicBoundaries(), SolutionUserObjectBase::SolutionUserObjectBase(), FixedPointSolve::solve(), TransientMultiApp::solveStep(), Moose::PetscSupport::storePetscOptions(), MultiAppDofCopyTransfer::transfer(), MultiAppMFEMTolibMeshShapeEvaluationTransfer::transferVariables(), Checkpoint::updateCheckpointFiles(), and SampledOutput::updateSample().

◆ mesh() [3/4]

MooseMesh & FEProblemBase::mesh ( bool use_displaced )

Definition at line 731 of file FEProblemBase.C.

{
  if (use_displaced && !_displaced_problem)
    mooseWarning("Displaced mesh was requested but the displaced problem does not exist. "
                 "Regular mesh will be returned");
  return ((use_displaced && _displaced_problem) ? _displaced_problem->mesh() : mesh());
}

◆ mesh() [4/4]

const MooseMesh & FEProblemBase::mesh ( bool use_displaced ) const

overridevirtual

Implements SubProblem.

Definition at line 722 of file FEProblemBase.C.

{
  if (use_displaced && !_displaced_problem)
    mooseWarning("Displaced mesh was requested but the displaced problem does not exist. "
                 "Regular mesh will be returned");
  return ((use_displaced && _displaced_problem) ? _displaced_problem->mesh() : mesh());
}

◆ meshChanged() [1/2]

virtual void FEProblemBase::meshChanged ( )

inlineprotectedvirtual

Deprecated.

Users should switch to overriding the meshChanged which takes arguments

Definition at line 3097 of file FEProblemBase.h.

3097{}

Referenced by adaptMesh(), initialAdaptMesh(), meshChanged(), timestepSetup(), uniformRefine(), and updateMeshXFEM().

◆ meshChanged() [2/2]

void FEProblemBase::meshChanged	(	bool	intermediate_change,
		bool	contract_mesh,
		bool	clean_refinement_flags
	)

virtual

Update data after a mesh change.

Iff intermediate_change is true, only perform updates as necessary to prepare for another mesh change immediately-subsequent. An example of data that is not updated during an intermediate change is libMesh System matrix data. An example of data that \emph is updated during an intermediate change is libMesh System vectors. These vectors are projected or restricted based off of adaptive mesh refinement or the changing of element subdomain IDs. The flags contract_mesh and clean_refinement_flags should generally only be set to true when the mesh has changed due to mesh refinement. contract_mesh deletes children of coarsened elements and renumbers nodes and elements. clean_refinement_flags resets refinement flags such that any subsequent calls to System::restrict_vectors or System::prolong_vectors before another AMR step do not mistakenly attempt to re-do the restriction/prolongation which occurred in this method. The value of contract_mesh is ignored when FEProblemBase::allowMeshContractionAfterMeshChanged is set to false.

Definition at line 9043 of file FEProblemBase.C.

{
  TIME_SECTION("meshChanged", 3, "Handling Mesh Changes");
 
  const bool should_contract = contract_mesh && allowMeshContractionAfterMeshChanged();
 
  _app.markMeshChangedForBackup();
 
  if (_material_props.hasStatefulProperties() || _bnd_material_props.hasStatefulProperties() ||
      _neighbor_material_props.hasStatefulProperties())
    _mesh.cacheChangedLists(); // Currently only used with adaptivity and stateful material
                               // properties
 
  // Clear these out because they corresponded to the old mesh
  _ghosted_elems.clear();
  ghostGhostedBoundaries();
 
  // The mesh changed.  We notify the MooseMesh first, because
  // callbacks (e.g. for sparsity calculations) triggered by the
  // EquationSystems reinit may require up-to-date MooseMesh caches.
  _mesh.meshChanged();
 
  // If we're just going to alter the mesh again, all we need to
  // handle here is AMR and projections, not full system reinit
  if (intermediate_change)
    es().reinit_solutions();
  else
    es().reinit();
 
  if (should_contract)
    // Once vectors are restricted, we can delete children of coarsened elements
    _mesh.getMesh().contract();
  if (clean_refinement_flags)
  {
    // Finally clear refinement flags so that if someone tries to project vectors again without
    // an intervening mesh refinement to clear flags they won't run into trouble
    libMesh::MeshRefinement refinement(_mesh.getMesh());
    refinement.clean_refinement_flags();
  }
 
  if (!intermediate_change)
  {
    // Since the mesh has changed, we need to make sure that we update any of our
    // MOOSE-system specific data.
    for (auto & sys : _solver_systems)
      sys->reinit();
    _aux->reinit();
  }
 
  // Updating MooseMesh first breaks other adaptivity code, unless we
  // then *again* update the MooseMesh caches.  E.g. the definition of
  // "active" and "local" may have been *changed* by refinement and
  // repartitioning done in EquationSystems::reinit().
  _mesh.meshChanged();
 
  // If we have finite volume variables, we will need to recompute additional elemental/face
  // quantities
  if (haveFV() && _mesh.isFiniteVolumeInfoDirty())
    _mesh.setupFiniteVolumeMeshData();
 
  // Let the meshChangedInterface notify the mesh changed event before we update the active
  // semilocal nodes, because the set of ghosted elements may potentially be updated during a mesh
  // changed event.
  for (const auto & mci : _notify_when_mesh_changes)
    mci->meshChanged();
 
  // Since the Mesh changed, update the PointLocator object used by DiracKernels.
  _dirac_kernel_info.updatePointLocator(_mesh);
 
  // Need to redo ghosting
  _geometric_search_data.reinit();
 
  if (_displaced_problem)
  {
    // Mesh contraction is necessary when a displaced problem is used.
    if (!allowMeshContractionAfterMeshChanged())
      mooseError("Disabling mesh contraction is not implemented when a displaced problem is used. "
                 "Please contact a "
                 "developer of this application to discuss the combination of these features.");
 
    _displaced_problem->meshChanged(should_contract, clean_refinement_flags);
    _displaced_mesh->updateActiveSemiLocalNodeRange(_ghosted_elems);
  }
 
  _mesh.updateActiveSemiLocalNodeRange(_ghosted_elems);
 
  _evaluable_local_elem_range.reset();
  _nl_evaluable_local_elem_range.reset();
 
  // Just like we reinitialized our geometric search objects, we also need to reinitialize our
  // mortar meshes. Note that this needs to happen after DisplacedProblem::meshChanged because the
  // mortar mesh discretization will depend necessarily on the displaced mesh being re-displaced
  _mortar_data->meshChanged();
 
  // Nonlinear systems hold the mortar mesh functors. The domains of definition of the mortar
  // functors might have changed when the mesh changed.
  for (auto & nl_sys : _nl)
    nl_sys->reinitMortarFunctors();
 
  reinitBecauseOfGhostingOrNewGeomObjects(/*mortar_changed=*/true);
 
  // We need to create new storage for newly active elements, and copy
  // stateful properties from the old elements.
  if (_has_initialized_stateful &&
      (_material_props.hasStatefulProperties() || _bnd_material_props.hasStatefulProperties()))
  {
    if (doingPRefinement())
      _mesh.buildPRefinementAndCoarseningMaps(_assembly[0][0].get());
 
    // Prolong properties onto newly refined elements' children
    {
      ProjectMaterialProperties pmp(
          /* refine = */ true, *this, _material_props, _bnd_material_props, _assembly);
      const auto & range = *_mesh.refinedElementRange();
      Threads::parallel_reduce(range, pmp, numThreads());
 
      // Concurrent erasure from the shared hash map is not safe while we are reading from it in
      // ProjectMaterialProperties, so we handle erasure here. Moreover, erasure based on key is
      // not thread safe in and of itself because it is a read-write operation. Note that we do not
      // do the erasure for p-refinement because the coarse level element is the same as our active
      // refined level element
      if (!doingPRefinement())
        for (const auto & elem : range)
        {
          _material_props.eraseProperty(elem);
          _bnd_material_props.eraseProperty(elem);
          _neighbor_material_props.eraseProperty(elem);
        }
    }
 
    // Restrict properties onto newly coarsened elements
    {
      ProjectMaterialProperties pmp(
          /* refine = */ false, *this, _material_props, _bnd_material_props, _assembly);
      const auto & range = *_mesh.coarsenedElementRange();
      Threads::parallel_reduce(range, pmp, numThreads());
      // Note that we do not do the erasure for p-refinement because the coarse level element is the
      // same as our active refined level element
      if (!doingPRefinement())
        for (const auto & elem : range)
        {
          auto && coarsened_children = _mesh.coarsenedElementChildren(elem);
          for (auto && child : coarsened_children)
          {
            _material_props.eraseProperty(child);
            _bnd_material_props.eraseProperty(child);
            _neighbor_material_props.eraseProperty(child);
          }
        }
    }
  }
 
  if (_calculate_jacobian_in_uo)
    setVariableAllDoFMap(_uo_jacobian_moose_vars[0]);
 
  _has_jacobian = false; // we have to recompute jacobian when mesh changed
 
  // Now for backwards compatibility with user code that overrode the old no-arg meshChanged we must
  // call it here
  meshChanged();
}

Referenced by MoveNodesByParsedExpressionModifier::execute(), ActivateElementsUserObjectBase::finalize(), SidesetAroundSubdomainUpdater::finalize(), Exodus::handleExodusIOMeshRenumbering(), ElementSubdomainModifierBase::modify(), MooseApp::restore(), TransientMultiApp::setupApp(), and Adaptivity::uniformRefineWithProjection().

◆ meshDisplaced()

void FEProblemBase::meshDisplaced ( )

protectedvirtual

Update data after a mesh displaced.

Definition at line 9220 of file FEProblemBase.C.

{
  for (const auto & mdi : _notify_when_mesh_displaces)
    mdi->meshDisplaced();
}

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

◆ messagePrefix() [1/2]

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

inlineinherited

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

Definition at line 256 of file MooseBase.h.

  {
    return messagePrefix(_pars, hit_prefix);
  }

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

◆ messagePrefix() [2/2]

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

staticprivateinherited

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

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

Definition at line 140 of file MooseBase.C.

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

◆ mooseDeprecated() [1/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 317 of file MooseBase.h.

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

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

◆ mooseDeprecated() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

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

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

◆ mooseDeprecatedNoTrace()

template<typename... Args>

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

inlineinherited

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

Definition at line 327 of file MooseBase.h.

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

Referenced by MooseApp::MooseApp().

◆ mooseDocumentedError()

template<typename... Args>

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

inlineinherited

Definition at line 277 of file MooseBase.h.

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

Referenced by ManifoldSubdomainGenerator::ManifoldSubdomainGenerator().

◆ mooseError()

template<typename... Args>

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

inlineinherited

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

Definition at line 271 of file MooseBase.h.

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

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 290 of file MooseBase.h.

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

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 334 of file MooseBase.h.

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

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

◆ mooseWarning() [1/2]

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

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

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

◆ mooseWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

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

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

◆ mooseWarningNonPrefixed() [1/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 308 of file MooseBase.h.

  {
    moose::internal::mooseWarningStream(_console, std::forward<Args>(args)...);
  }

◆ mooseWarningNonPrefixed() [2/2]

template<typename... Args>

void SolutionInvalidInterface::mooseWarningNonPrefixed ( Args &&... args ) const

inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseWarningNonPrefixed(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
  }

◆ mortarData() [1/2]

MortarInterfaceWarehouse & FEProblemBase::mortarData ( )

inline

Definition at line 2757 of file FEProblemBase.h.

2757{ return *_mortar_data; }

◆ mortarData() [2/2]

const MortarInterfaceWarehouse & FEProblemBase::mortarData ( ) const

inline

Returns the mortar data object.

Definition at line 2756 of file FEProblemBase.h.

2756{ return *_mortar_data; }

◆ name()

const std::string & MooseBase::name ( ) const

inlineinherited

Get the name of the class.

Returns: The name of the class

Definition at line 103 of file MooseBase.h.

  {
    mooseAssert(_name.size(), "Empty name");
    return _name;
  }

◆ needBoundaryMaterialOnSide()

bool FEProblemBase::needBoundaryMaterialOnSide	(	BoundaryID	bnd_id,
		const THREAD_ID	tid
	)

These methods are used to determine whether stateful material properties need to be stored on internal sides.

There are five situations where this may be the case: 1) DGKernels 2) IntegratedBCs 3)InternalSideUserObjects 4)ElementalAuxBCs 5)InterfaceUserObjects

Method 1:

Parameters

bnd_id	the boundary id for which to see if stateful material properties need to be stored
tid	the THREAD_ID of the caller

Returns: Boolean indicating whether material properties need to be stored

Method 2:

Parameters

subdomain_id	the subdomain id for which to see if stateful material properties need to be stored
tid	the THREAD_ID of the caller

Returns: Boolean indicating whether material properties need to be stored

Definition at line 9686 of file FEProblemBase.C.

{
  if (_bnd_mat_side_cache[tid].find(bnd_id) == _bnd_mat_side_cache[tid].end())
  {
    auto & bnd_mat_side_cache = _bnd_mat_side_cache[tid][bnd_id];
    bnd_mat_side_cache = false;
 
    // Check systems
    if (_aux->needMaterialOnSide(bnd_id))
    {
      bnd_mat_side_cache = true;
      return true;
    }
    for (auto & nl : _nl)
      if (nl->needBoundaryMaterialOnSide(bnd_id, tid))
      {
        bnd_mat_side_cache = true;
        return true;
      }
 
    // TODO: these objects should be checked for whether they actually consume materials
    // NOTE: InterfaceUO can use use boundary properties too
    if (theWarehouse()
            .query()
            .condition<AttribThread>(tid)
            .condition<AttribInterfaces>(Interfaces::SideUserObject | Interfaces::DomainUserObject |
                                         Interfaces::InterfaceUserObject)
            .condition<AttribBoundaries>(bnd_id)
            .count() > 0)
    {
      bnd_mat_side_cache = true;
      return true;
    }
  }
 
  return _bnd_mat_side_cache[tid][bnd_id];
}

Referenced by ComputeMaterialsObjectThread::onBoundary(), ProjectMaterialProperties::onBoundary(), reinitMaterialsBoundary(), reinitMaterialsFaceOnBoundary(), and reinitMaterialsNeighborOnBoundary().

◆ needFV()

virtual void FEProblemBase::needFV ( )

inlineoverridevirtual

marks this problem as including/needing finite volume functionality.

Implements SubProblem.

Definition at line 3030 of file FEProblemBase.h.

3030{ _have_fv = true; }

Referenced by DiffusionFV::initializePhysicsAdditional(), and DisplacedProblem::needFV().

◆ needInterfaceMaterialOnSide()

bool FEProblemBase::needInterfaceMaterialOnSide	(	BoundaryID	bnd_id,
		const THREAD_ID	tid
	)

Definition at line 9725 of file FEProblemBase.C.

{
  if (_interface_mat_side_cache[tid].find(bnd_id) == _interface_mat_side_cache[tid].end())
  {
    auto & interface_mat_side_cache = _interface_mat_side_cache[tid][bnd_id];
    interface_mat_side_cache = false;
 
    // Aux-system has not needed interface materials so far
    for (auto & nl : _nl)
      if (nl->needInterfaceMaterialOnSide(bnd_id, tid))
      {
        interface_mat_side_cache = true;
        return true;
      }
 
    // TODO: these objects should be checked for whether they actually consume materials
    if (theWarehouse()
            .query()
            .condition<AttribThread>(tid)
            .condition<AttribInterfaces>(Interfaces::InterfaceUserObject |
                                         Interfaces::DomainUserObject)
            .condition<AttribBoundaries>(bnd_id)
            .count() > 0)
    {
      interface_mat_side_cache = true;
      return true;
    }
    else if (_interface_materials.hasActiveBoundaryObjects(bnd_id, tid))
    {
      interface_mat_side_cache = true;
      return true;
    }
  }
  return _interface_mat_side_cache[tid][bnd_id];
}

Referenced by ComputeMaterialsObjectThread::onInterface(), reinitMaterialsFaceOnBoundary(), reinitMaterialsInterface(), and reinitMaterialsNeighborOnBoundary().

◆ needInternalNeighborSideMaterial()

bool FEProblemBase::needInternalNeighborSideMaterial	(	SubdomainID	subdomain_id,
		const THREAD_ID	tid
	)

Definition at line 9762 of file FEProblemBase.C.

{
  if (_block_mat_side_cache[tid].find(subdomain_id) == _block_mat_side_cache[tid].end())
  {
    _block_mat_side_cache[tid][subdomain_id] = false;
 
    for (auto & nl : _nl)
      if (nl->needInternalNeighborSideMaterial(subdomain_id, tid))
      {
        _block_mat_side_cache[tid][subdomain_id] = true;
        return true;
      }
 
    // TODO: these objects should be checked for whether they actually consume materials
    if (theWarehouse()
            .query()
            .condition<AttribThread>(tid)
            .condition<AttribInterfaces>(Interfaces::InternalSideUserObject |
                                         Interfaces::DomainUserObject)
            .condition<AttribSubdomains>(subdomain_id)
            .count() > 0)
    {
      _block_mat_side_cache[tid][subdomain_id] = true;
      return true;
    }
  }
 
  return _block_mat_side_cache[tid][subdomain_id];
}

Referenced by reinitMaterialsFaceOnBoundary(), reinitMaterialsNeighborOnBoundary(), ComputeMaterialsObjectThread::subdomainChanged(), and ProjectMaterialProperties::subdomainChanged().

◆ needSolutionState()

void FEProblemBase::needSolutionState	(	unsigned int	oldest_needed,
		Moose::SolutionIterationType	iteration_type
	)

Declare that we need up to old (1) or older (2) solution states for a given type of iteration.

Parameters

oldest_needed	oldest solution state needed
iteration_type	the type of iteration for which old/older states are needed

Definition at line 804 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    sys->needSolutionState(state, iteration_type);
  _aux->needSolutionState(state, iteration_type);
}

Referenced by createTagSolutions().

◆ needsPreviousMultiAppFixedPointIterationAuxiliary() [1/2]

bool FEProblemBase::needsPreviousMultiAppFixedPointIterationAuxiliary ( ) const

Check to see whether we need to compute the variable values of the previous multiapp fixed point iteration for the auxiliary system.

Returns: true if the user required values of the previous multiapp fixed point iteration from the auxiliary system

Definition at line 9827 of file FEProblemBase.C.

{
  return _previous_multiapp_fp_aux_solution_required;
}

◆ needsPreviousMultiAppFixedPointIterationAuxiliary() [2/2]

void FEProblemBase::needsPreviousMultiAppFixedPointIterationAuxiliary ( bool state )

Set a flag that indicated that user required values for the previous multiapp fixed point iterate for the auxiliary system.

Definition at line 9821 of file FEProblemBase.C.

{
  _previous_multiapp_fp_aux_solution_required = state;
}

Referenced by FunctorChangeFunctorMaterialTempl< is_ad >::FunctorChangeFunctorMaterialTempl(), and FixedPointSolve::initialSetup().

◆ needsPreviousMultiAppFixedPointIterationSolution() [1/2]

void FEProblemBase::needsPreviousMultiAppFixedPointIterationSolution	(	bool	needed,
		const unsigned int	solver_sys_num
	)

Set a flag that indicated that user required values for the previous multiapp fixed point iterate for the solver systems (not auxiliary)

Parameters

needed	the value that should be set to the flag
solver_sys_num	the index of the solver system for which the previous iteration is needed

Definition at line 9807 of file FEProblemBase.C.

{
  _previous_multiapp_fp_nl_solution_required[solver_sys_num] = needed;
}

Referenced by FunctorChangeFunctorMaterialTempl< is_ad >::FunctorChangeFunctorMaterialTempl(), and FixedPointSolve::initialSetup().

◆ needsPreviousMultiAppFixedPointIterationSolution() [2/2]

bool FEProblemBase::needsPreviousMultiAppFixedPointIterationSolution ( const unsigned int solver_sys_num ) const

Check to see whether we need to compute the variable values of the previous multiapp fixed point iteration for the solver systems (not auxiliary)

Parameters

solver_sys_num the index of the solver system for which the previous iteration is needed

Returns: true if the user required values of the previous multiapp fixed point iteration

Definition at line 9814 of file FEProblemBase.C.

{
  return _previous_multiapp_fp_nl_solution_required[solver_sys_num];
}

◆ needsPreviousMultiSystemFixedPointIterationAuxiliary() [1/2]

bool FEProblemBase::needsPreviousMultiSystemFixedPointIterationAuxiliary ( ) const

Check to see whether we need to compute the variable values of the previous multi-system fixed point iteration for the auxiliary system.

Returns: true if the user required values of the previous multi-system fixed point iteration from the auxiliary system

Definition at line 9853 of file FEProblemBase.C.

{
  return _previous_multisystem_fp_aux_solution_required;
}

◆ needsPreviousMultiSystemFixedPointIterationAuxiliary() [2/2]

void FEProblemBase::needsPreviousMultiSystemFixedPointIterationAuxiliary ( bool state )

Set a flag that indicates that user requires values for the previous multi-system fixed point iterate for the auxiliary system.

Definition at line 9847 of file FEProblemBase.C.

{
  _previous_multisystem_fp_aux_solution_required = state;
}

Referenced by FunctorChangeFunctorMaterialTempl< is_ad >::FunctorChangeFunctorMaterialTempl(), and FEProblemSolve::initialSetup().

◆ needsPreviousMultiSystemFixedPointIterationSolution() [1/2]

void FEProblemBase::needsPreviousMultiSystemFixedPointIterationSolution	(	bool	needed,
		const unsigned int	solver_sys_num
	)

Set a flag that indicates that user requires values for the previous multi-system fixed point iterate for the solver systems (not auxiliary)

Parameters

needed	the value that should be set to the flag
solver_sys_num	the index of the solver system for which the previous iteration is needed

Definition at line 9833 of file FEProblemBase.C.

{
  _previous_multisystem_fp_nl_solution_required[solver_sys_num] = needed;
}

Referenced by FunctorChangeFunctorMaterialTempl< is_ad >::FunctorChangeFunctorMaterialTempl(), and FEProblemSolve::initialSetup().

◆ needsPreviousMultiSystemFixedPointIterationSolution() [2/2]

bool FEProblemBase::needsPreviousMultiSystemFixedPointIterationSolution ( const unsigned int solver_sys_num ) const

Check to see whether we need to compute the variable values of the previous multi-system fixed point iteration for the solver systems (not auxiliary)

Parameters

solver_sys_num the index of the solver system for which the previous iteration is needed

Returns: true if the user required values of the previous multi-system fixed point iteration

Definition at line 9840 of file FEProblemBase.C.

{
  return _previous_multisystem_fp_nl_solution_required[solver_sys_num];
}

◆ needsPreviousNewtonIteration() [1/2]

bool FEProblemBase::needsPreviousNewtonIteration ( ) const

Check to see whether we need to compute the variable values of the previous Newton iterate.

Returns: true if the user required values of the previous Newton iterate

Definition at line 9793 of file FEProblemBase.C.

{
  return vectorTagExists(Moose::PREVIOUS_NL_SOLUTION_TAG);
}

◆ needsPreviousNewtonIteration() [2/2]

void FEProblemBase::needsPreviousNewtonIteration ( bool state )

Set a flag that indicated that user required values for the previous Newton iterate.

Definition at line 9799 of file FEProblemBase.C.

{
  if (state && !vectorTagExists(Moose::PREVIOUS_NL_SOLUTION_TAG))
    mooseError("Previous nonlinear solution is required but not added through "
               "Problem/previous_nl_solution_required=true");
}

Referenced by Coupleable::coupledGradientPreviousNL(), Coupleable::coupledNodalValuePreviousNL(), Coupleable::coupledSecondPreviousNL(), Coupleable::coupledValuePreviousNL(), and NonlinearSystem::solve().

◆ needToAddDefaultMultiAppFixedPointConvergence()

bool FEProblemBase::needToAddDefaultMultiAppFixedPointConvergence ( ) const

inline

Returns true if the problem needs to add the default fixed point convergence.

Definition at line 768 of file FEProblemBase.h.

  {
    return _need_to_add_default_multiapp_fixed_point_convergence;
  }

◆ needToAddDefaultNonlinearConvergence()

bool FEProblemBase::needToAddDefaultNonlinearConvergence ( ) const

inline

Returns true if the problem needs to add the default nonlinear convergence.

Definition at line 763 of file FEProblemBase.h.

  {
    return _need_to_add_default_nonlinear_convergence;
  }

◆ needToAddDefaultSteadyStateConvergence()

bool FEProblemBase::needToAddDefaultSteadyStateConvergence ( ) const

inline

Returns true if the problem needs to add the default steady-state detection convergence.

Definition at line 773 of file FEProblemBase.h.

  {
    return _need_to_add_default_steady_state_convergence;
  }

◆ neighborSubdomainSetup()

void FEProblemBase::neighborSubdomainSetup	(	SubdomainID	subdomain,
		const THREAD_ID	tid
	)

virtual

Definition at line 2710 of file FEProblemBase.C.

{
  _all_materials.neighborSubdomainSetup(subdomain, tid);
}

Referenced by ThreadedFaceLoop< RangeType >::neighborSubdomainChanged().

◆ newAssemblyArray()

void FEProblemBase::newAssemblyArray ( std::vector< std::shared_ptr< SolverSystem > > & solver_systems )

virtual

Definition at line 823 of file FEProblemBase.C.

{
  unsigned int n_threads = numThreads();
 
  _assembly.resize(n_threads);
  for (const auto i : make_range(n_threads))
  {
    _assembly[i].resize(solver_systems.size());
    for (const auto j : index_range(solver_systems))
      _assembly[i][j] = std::make_unique<Assembly>(*solver_systems[j], i);
  }
}

Referenced by DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), ExternalProblem::ExternalProblem(), and FEProblem::FEProblem().

◆ nlConverged()

bool SubProblem::nlConverged ( const unsigned int nl_sys_num )

virtualinherited

Returns: whether the given nonlinear system nl_sys_num is converged.

Definition at line 708 of file SubProblem.C.

{
  mooseAssert(nl_sys_num < numNonlinearSystems(),
              "The nonlinear system number is higher than the number of systems we have!");
  return solverSystemConverged(nl_sys_num);
}

◆ nLinearIterations()

unsigned int FEProblemBase::nLinearIterations ( const unsigned int nl_sys_num ) const

overridevirtual

Reimplemented from SubProblem.

Definition at line 7458 of file FEProblemBase.C.

{
  return _nl[nl_sys_num]->nLinearIterations();
}

Referenced by PiecewiseLinearFromVectorPostprocessor::valueInternal().

◆ nlSysNum()

unsigned int FEProblemBase::nlSysNum ( const NonlinearSystemName & nl_sys_name ) const

overridevirtual

Returns: the nonlinear system number corresponding to the provided nl_sys_name

Implements SubProblem.

Definition at line 7189 of file FEProblemBase.C.

{
  std::istringstream ss(nl_sys_name);
  unsigned int nl_sys_num;
  if (!(ss >> nl_sys_num) || !ss.eof())
    nl_sys_num = libmesh_map_find(_nl_sys_name_to_num, nl_sys_name);
 
  return nl_sys_num;
}

Referenced by DisplacedProblem::nlSysNum().

◆ nNonlinearIterations()

unsigned int FEProblemBase::nNonlinearIterations ( const unsigned int nl_sys_num ) const

overridevirtual

Reimplemented from SubProblem.

Definition at line 7452 of file FEProblemBase.C.

{
  return _nl[nl_sys_num]->nNonlinearIterations();
}

Referenced by PiecewiseLinearFromVectorPostprocessor::valueInternal().

◆ nonlocalCouplingEntries()

std::vector< std::pair< MooseVariableFieldBase , MooseVariableFieldBase > > & FEProblemBase::nonlocalCouplingEntries	(	const THREAD_ID	tid,
		const unsigned int	nl_sys_num
	)

Definition at line 7035 of file FEProblemBase.C.

{
  return _assembly[tid][nl_sys]->nonlocalCouplingEntries();
}

Referenced by ComputeFullJacobianThread::computeOnBoundary(), and ComputeFullJacobianThread::computeOnElement().

◆ nonlocalCouplingMatrix()

const libMesh::CouplingMatrix & FEProblemBase::nonlocalCouplingMatrix ( const unsigned i ) const

overridevirtual

Returns: the nonlocal coupling matrix for the i'th nonlinear system

Implements SubProblem.

Definition at line 10485 of file FEProblemBase.C.

{
  return _nonlocal_cm[i];
}

Referenced by DisplacedProblem::nonlocalCouplingMatrix().

◆ notifyWhenMeshChanges()

void FEProblemBase::notifyWhenMeshChanges ( MeshChangedInterface * mci )

Register an object that derives from MeshChangedInterface to be notified when the mesh changes.

Definition at line 9208 of file FEProblemBase.C.

{
  _notify_when_mesh_changes.push_back(mci);
}

Referenced by MeshChangedInterface::MeshChangedInterface().

◆ notifyWhenMeshDisplaces()

void FEProblemBase::notifyWhenMeshDisplaces ( MeshDisplacedInterface * mdi )

Register an object that derives from MeshDisplacedInterface to be notified when the displaced mesh gets updated.

Definition at line 9214 of file FEProblemBase.C.

{
  _notify_when_mesh_displaces.push_back(mdi);
}

Referenced by MeshDisplacedInterface::MeshDisplacedInterface().

◆ numConcurrentMultiApps()

unsigned int FEProblemBase::numConcurrentMultiApps ( ) const

inline

Returns: the number set for concurrent multiapp execution; greater than 1 enables running the multiapps of an 'execution_order_group' concurrently, each on its own subset of ranks

Definition at line 1732 of file FEProblemBase.h.

1732{ return _num_concurrent_multiapps; }

◆ numGridSteps()

void FEProblemBase::numGridSteps ( unsigned int num_grid_steps )

inline

Set the number of steps in a grid sequences.

Definition at line 2778 of file FEProblemBase.h.

2778{ _num_grid_steps = num_grid_steps; }

Referenced by FEProblemSolve::FEProblemSolve().

◆ numLinearSystems()

virtual std::size_t FEProblemBase::numLinearSystems ( ) const

inlineoverridevirtual

Returns: the number of linear systems in the problem

Implements SubProblem.

Definition at line 2936 of file FEProblemBase.h.

2936{ return _num_linear_sys; }

Referenced by IterationAdaptiveDT::acceptStep(), addPredictor(), IterationAdaptiveDT::computeAdaptiveDT(), FEProblemSolve::FEProblemSolve(), EigenProblem::init(), Console::meshChanged(), DisplacedProblem::numLinearSystems(), Console::outputSystemInformation(), Moose::PetscSupport::petscSetDefaults(), and setLinearConvergenceNames().

◆ numMatrixTags()

virtual unsigned int SubProblem::numMatrixTags ( ) const

inlinevirtualinherited

The total number of tags.

Reimplemented in DisplacedProblem.

Definition at line 251 of file SubProblem.h.

251{ return _matrix_tag_name_to_tag_id.size(); }

Referenced by SystemBase::activateAllMatrixTags(), NonlinearSystemBase::computeNodalBCsJacobian(), NonlinearSystemBase::computeScalarKernelsJacobians(), SystemBase::deactivateAllMatrixTags(), ComputeJacobianThread::determineObjectWarehouses(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), DisplacedProblem::numMatrixTags(), ComputeNodalKernelBCJacobiansThread::pre(), ComputeNodalKernelJacobiansThread::pre(), MooseVariableScalar::sizeMatrixTagData(), and ComputeDiracThread::subdomainChanged().

◆ numNonlinearSystems()

virtual std::size_t FEProblemBase::numNonlinearSystems ( ) const

inlineoverridevirtual

Returns: the number of nonlinear systems in the problem

Implements SubProblem.

Definition at line 2934 of file FEProblemBase.h.

2934{ return _num_nl_sys; }

Referenced by IterationAdaptiveDT::acceptStep(), addPredictor(), DisplacedProblem::addTimeIntegrator(), DisplacedProblem::DisplacedProblem(), Executioner::Executioner(), EigenProblem::init(), jacobianSetup(), PNGOutput::makeMeshFunc(), Console::meshChanged(), DisplacedProblem::numNonlinearSystems(), ComputeBoundaryInitialConditionThread::onNode(), BoundaryElemIntegrityCheckThread::operator()(), ConsoleUtils::outputExecutionInformation(), Console::outputSystemInformation(), Moose::PetscSupport::petscSetDefaults(), ReferenceResidualConvergence::ReferenceResidualConvergence(), residualSetup(), Moose::SlepcSupport::setEigenProblemSolverParams(), Moose::PetscSupport::setLineSearchFromParams(), Moose::PetscSupport::setMFFDTypeFromParams(), setNonlinearConvergenceNames(), Moose::PetscSupport::setSolveTypeFromParams(), FEProblemSolve::solve(), solveLinearSystem(), Moose::SlepcSupport::storeSolveType(), and Console::writeVariableNorms().

◆ numSolverSystems()

virtual std::size_t FEProblemBase::numSolverSystems ( ) const

inlineoverridevirtual

Returns: the number of solver systems in the problem

Implements SubProblem.

Definition at line 2938 of file FEProblemBase.h.

2938{ return _num_nl_sys + _num_linear_sys; }

Referenced by Adaptivity::adaptMesh(), Moose::PetscSupport::addPetscOptionsFromCommandline(), ElementSubdomainModifierBase::applyIC(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), EigenProblemSolve::EigenProblemSolve(), FEProblemBase(), TransientBase::getTimeIntegratorNames(), Adaptivity::init(), FixedPointSolve::initialSetup(), DisplacedProblem::numSolverSystems(), ConsoleUtils::outputExecutionInformation(), Moose::PetscSupport::petscSetDefaultKSPNormType(), Moose::PetscSupport::petscSetDefaultPCSide(), and solverParams().

◆ numThreads()

THREAD_ID SubProblem::numThreads ( ) const

inherited

Returns: the number of threads the associated application uses (see MooseApp::numThreads())

Definition at line 81 of file SubProblem.C.

81{ return getMooseApp().numThreads(); }

MooseApp::numThreads

THREAD_ID numThreads() const

Returns the number of threads this application uses.

Definition MooseApp.h:421

Referenced by Adaptivity::adaptMesh(), addConvergence(), addFunction(), addFunctorMaterial(), addFVInitialCondition(), addFVInterpolationMethod(), addIndicator(), addInitialCondition(), addMarker(), addMaterialHelper(), addMeshDivision(), addObject(), addUserObject(), bumpAllQRuleOrder(), DisplacedProblem::bumpAllQRuleOrder(), bumpVolumeQRuleOrder(), DisplacedProblem::bumpVolumeQRuleOrder(), checkNonlocalCoupling(), computeBounds(), computeIndicators(), computeJacobianTags(), computeLinearSystemTags(), computeMarkers(), computeResidualAndJacobian(), computeResidualTags(), computeUserObjectsInternal(), createQRules(), DisplacedProblem::createQRules(), customSetup(), PenetrationLocator::detectPenetration(), DisplacedProblem::DisplacedProblem(), executeSamplers(), FEProblemBase(), NearestNodeLocator::findNodes(), DisplacedProblem::init(), FEProblem::init(), init(), initElementStatefulProps(), DumpObjectsProblem::initialSetup(), initialSetup(), initXFEM(), MaterialPropertyStorage::MaterialPropertyStorage(), meshChanged(), newAssemblyArray(), PenetrationLocator::PenetrationLocator(), SubProblem::preparePRefinement(), projectInitialConditionOnCustomRange(), projectSolution(), reinitDirac(), FixedPointSolve::solve(), TransientMultiApp::solveStep(), SubProblem::SubProblem(), timestepSetup(), DisplacedProblem::undisplaceMesh(), updateActiveObjects(), Adaptivity::updateErrorVectors(), updateMaxQps(), DisplacedProblem::updateMesh(), DisplacedProblem::updateMesh(), NearestNodeLocator::updatePatch(), ~FEProblemBase(), and PenetrationLocator::~PenetrationLocator().

◆ numVectorTags()

unsigned int SubProblem::numVectorTags ( const Moose::VectorTagType type = Moose::VECTOR_TAG_ANY ) const

virtualinherited

The total number of tags, which can be limited to the tag type.

Reimplemented in DisplacedProblem.

Definition at line 187 of file SubProblem.C.

{
  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
 
  return getVectorTags(type).size();
}

Referenced by NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeResidualInternal(), ComputeResidualThread::determineObjectWarehouses(), MooseVariableDataBase< OutputType >::MooseVariableDataBase(), MooseVariableScalar::MooseVariableScalar(), DisplacedProblem::numVectorTags(), ComputeNodalKernelBcsThread::pre(), and ComputeNodalKernelsThread::pre().

◆ objectExecuteHelper()

template<typename T >

void FEProblemBase::objectExecuteHelper ( const std::vector< T * > & objects )

static

Definition at line 3813 of file FEProblemBase.h.

{
  for (T * obj_ptr : objects)
    obj_ptr->execute();
}

◆ objectSetupHelper()

template<typename T >

void FEProblemBase::objectSetupHelper	(	const std::vector< T * > &	objects,
		const ExecFlagType &	exec_flag
	)

static

Helpers for calling the necessary setup/execute functions for the supplied objects.

Definition at line 3779 of file FEProblemBase.h.

{
  if (exec_flag == EXEC_INITIAL)
  {
    for (T * obj_ptr : objects)
      obj_ptr->initialSetup();
  }
 
  else if (exec_flag == EXEC_TIMESTEP_BEGIN)
  {
    for (const auto obj_ptr : objects)
      obj_ptr->timestepSetup();
  }
  else if (exec_flag == EXEC_SUBDOMAIN)
  {
    for (const auto obj_ptr : objects)
      obj_ptr->subdomainSetup();
  }
 
  else if (exec_flag == EXEC_NONLINEAR)
  {
    for (const auto obj_ptr : objects)
      obj_ptr->jacobianSetup();
  }
 
  else if (exec_flag == EXEC_LINEAR)
  {
    for (const auto obj_ptr : objects)
      obj_ptr->residualSetup();
  }
}

◆ onlyAllowDefaultNonlinearConvergence()

virtual bool FEProblemBase::onlyAllowDefaultNonlinearConvergence ( ) const

inlinevirtual

Returns true if an error will result if the user supplies 'nonlinear_convergence'.

Some problems are strongly tied to their convergence, and it does not make sense to use any convergence other than their default and additionally would be error-prone.

Reimplemented in ReferenceResidualProblem.

Definition at line 817 of file FEProblemBase.h.

817{ return false; }

Referenced by FEProblemSolve::FEProblemSolve().

◆ onTimestepBegin()

void FEProblemBase::onTimestepBegin ( )

overridevirtual

Implements SubProblem.

Definition at line 7640 of file FEProblemBase.C.

{
  TIME_SECTION("onTimestepBegin", 2);
 
  for (auto & nl : _nl)
    nl->onTimestepBegin();
}

Referenced by TransientBase::takeStep(), and MFEMTransient::takeStep().

◆ onTimestepEnd()

void FEProblemBase::onTimestepEnd ( )

overridevirtual

Implements SubProblem.

Reimplemented in DumpObjectsProblem.

Definition at line 7649 of file FEProblemBase.C.

7650{

7651}

Referenced by EigenExecutionerBase::init(), NonlinearEigen::init(), FixedPointSolve::solveStep(), InversePowerMethod::takeStep(), and NonlinearEigen::takeStep().

◆ outputStep()

void FEProblemBase::outputStep ( ExecFlagType type )

virtual

Output the current step.

Will ensure that everything is in the proper state to be outputted. Then tell the OutputWarehouse to do its thing

Parameters

type	The type execution flag (see Moose.h)

Reimplemented in DumpObjectsProblem.

Definition at line 7603 of file FEProblemBase.C.

{
  TIME_SECTION("outputStep", 1, "Outputting");
 
  setCurrentExecuteOnFlag(type);
 
  for (auto & sys : _solver_systems)
    sys->update();
  _aux->update();
 
  if (_displaced_problem)
    _displaced_problem->syncSolutions();
  _app.getOutputWarehouse().outputStep(type);
 
  setCurrentExecuteOnFlag(EXEC_NONE);
}

Referenced by TransientBase::endStep(), Eigenvalue::execute(), SteadyBase::execute(), TransientBase::execute(), MFEMSteady::execute(), InversePowerMethod::init(), NonlinearEigen::init(), EigenExecutionerBase::postExecute(), TransientBase::preExecute(), FEProblemSolve::solve(), FixedPointSolve::solve(), FixedPointSolve::solveStep(), and TransientMultiApp::solveStep().

◆ paramError()

template<typename... Args>

void MooseBase::paramError	(	const std::string &	param,
		Args...	args
	)		const

inherited

Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseError - only printing a message using the given args.

Definition at line 457 of file MooseBase.h.

{
  _pars.paramError(param, std::forward<Args>(args)...);
}

◆ parameters()

const InputParameters & MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 131 of file MooseBase.h.

131{ return _pars; }

◆ paramInfo()

template<typename... Args>

void MooseBase::paramInfo	(	const std::string &	param,
		Args...	args
	)		const

inherited

Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseInfo - only printing a message using the given args.

Definition at line 471 of file MooseBase.h.

{
  mooseInfo(_pars.paramMessage(param, std::forward<Args>(args)...));
}

Referenced by GridPartitioner::_do_partition(), ComboMarker::ComboMarker(), Control::Control(), execMultiApps(), FunctorIC::FunctorIC(), and TransientMultiApp::TransientMultiApp().

◆ paramWarning() [1/2]

template<typename... Args>

void MooseBase::paramWarning	(	const std::string &	param,
		Args...	args
	)		const

inherited

Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseWarning - only printing a message using the given args.

Definition at line 464 of file MooseBase.h.

{
  mooseWarning(_pars.paramMessage(param, std::forward<Args>(args)...));
}

◆ paramWarning() [2/2]

template<typename... Args>

void SolutionInvalidInterface::paramWarning	(	const std::string &	param,
		Args...	args
	)		const

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::paramWarning(param, std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning for parameter '" +
                                            param + "'");
  }

Referenced by GridPartitioner::_do_partition(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), MooseMeshUtils::copyIntoMesh(), CylindricalGridDivision::CylindricalGridDivision(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), PlaneIDMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), ReferenceResidualConvergence::initialSetup(), SolutionIC::initialSetup(), FullSolveMultiApp::initialSetup(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), MultiAppTransfer::MultiAppTransfer(), PNGOutput::PNGOutput(), setPreserveMatrixSparsityPattern(), Terminator::Terminator(), and SolutionAux::validateVariable().

◆ parentOutputPositionChanged()

void FEProblemBase::parentOutputPositionChanged ( )

Calls parentOutputPositionChanged() on all sub apps.

Definition at line 5071 of file FEProblemBase.C.

{
  for (const auto & it : _multi_apps)
  {
    const auto & objects = it.second.getActiveObjects();
    for (const auto & obj : objects)
      obj->parentOutputPositionChanged();
  }
}

Referenced by TransientBase::parentOutputPositionChanged().

◆ partitionConcurrentMultiApps()

void FEProblemBase::partitionConcurrentMultiApps ( )

Assign each multiapp that shares an 'execution_order_group' with others a disjoint subset of the ranks so that they can be solved concurrently (at most one child app per rank at a time).

Note that each MultiApp may have multiple child applications, and each child app may use more than one rank.

Only does anything when 'num_concurrent_multiapps' > 1.
Must be called before the sub-apps are created.

Definition at line 6133 of file FEProblemBase.C.

{
  if (_num_concurrent_multiapps <= 1)
    return;
 
  // Group the multiapps by execution order group. Only position-based multiapps are partitioned
  // here; sampler-style (non-positions) multiapps assign their own rank configuration.
  std::map<unsigned int, std::vector<std::shared_ptr<MultiApp>>> groups;
  for (const auto & multi_app : _multi_apps.getActiveObjects())
    if (multi_app->usingPositions())
      groups[multi_app->getParam<unsigned int>("execution_order_group")].push_back(multi_app);
 
  // For the MultiApps that are using samplers, their partitioning is already handled there
  // so we just skipped them. But if they were to share an execution_order_group, we would crash
  // if using concurrent multiapps. So let's error.
  // For any other MultiApps that are not using positions, we would just need them to know
  // numGlobalApps() to benefit from this concurrent partitioning. We can allow them here in the
  // future.
  std::map<unsigned int, std::vector<std::shared_ptr<MultiApp>>> check_groups;
  for (const auto & multi_app : _multi_apps.getActiveObjects())
    check_groups[multi_app->getParam<unsigned int>("execution_order_group")].push_back(multi_app);
  for (const auto & [group_id, group] : check_groups)
    for (const auto & multi_app : group)
      if (group.size() > 1 && !multi_app->usingPositions())
        multi_app->paramError(
            "execution_order_group",
            "This MultiApp must be placed in its own execution order group as concurrent execution "
            "has not been implemented for this type of app at this time");
 
  const auto n_procs = n_processors();
  const auto my_rank = processor_id();
 
  for (const auto & [group_id, group] : groups)
  {
    // Nothing to run concurrently unless the group has more than one multiapp
    if (group.size() < 2)
      continue;
 
    // Number of ranks handed to each multiapp. Start each at its per-app minimum (at least one
    // rank), then distribute the rest; caps prevent giving a multiapp more ranks than it could
    // spread its apps over at 'max_procs_per_app'. With the defaults (min 1, max unbounded) this
    // is just an even split.
    std::vector<processor_id_type> count(group.size());
    std::vector<processor_id_type> caps(group.size());
    std::vector<processor_id_type> mins(group.size());
    std::vector<processor_id_type> maxs(group.size());
    processor_id_type min_total = 0;
    for (const auto m : index_range(group))
    {
      // Each multiapp needs at least one rank, so a 'min_procs_per_app' of 0 is treated as 1
      mins[m] = group[m]->getParam<processor_id_type>("min_procs_per_app");
      maxs[m] = group[m]->getParam<processor_id_type>("max_procs_per_app");
      const auto n_apps_m = cast_int<processor_id_type>(group[m]->numGlobalApps());
      caps[m] = (maxs[m] >= n_procs) ? n_procs : std::min(n_procs, n_apps_m * maxs[m]);
      count[m] = mins[m];
      min_total += mins[m];
    }
 
    if (min_total > n_procs)
      mooseError("Not enough MPI ranks to run the ",
                 group.size(),
                 " multiapps of 'execution_order_group' ",
                 group_id,
                 " concurrently: they need at least ",
                 min_total,
                 " ranks (from 'min_procs_per_app') but only ",
                 n_procs,
                 " are available. Reduce the number of concurrent multiapps, lower "
                 "'min_procs_per_app', or run with more processors.");
 
    // Hand out the remaining ranks round-robin to multiapps still below their cap
    processor_id_type remaining = n_procs - min_total;
    bool progress = true;
    while (remaining > 0 && progress)
    {
      progress = false;
      for (const auto m : index_range(group))
        if (remaining > 0 && count[m] < caps[m])
        {
          count[m]++;
          remaining--;
          progress = true;
        }
    }
    // Any leftover ranks (all multiapps already at their cap) simply run no app in this group.
 
    // Assign each multiapp a contiguous, disjoint rank range and (re)initialize it on that range.
    // This is collective: every rank calls init() (hence buildComm's split) for every multiapp.
    processor_id_type offset = 0;
    for (const auto m : index_range(group))
    {
      LocalRankConfig cfg{0, 0, 0, 0, false, 0};
      if (my_rank >= offset && my_rank < offset + count[m])
        cfg = rankConfig(
            my_rank - offset, count[m], group[m]->numGlobalApps(), mins[m], maxs[m], false);
      group[m]->init(group[m]->numGlobalApps(), cfg);
      offset += count[m];
    }
  }
}

◆ perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

{
  return _pg_moose_app.perfGraph();
}

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), PerfGraphReporter::finalize(), and PerfGraphOutput::output().

◆ petscOptionsDatabase()

PetscOptions & FEProblemBase::petscOptionsDatabase ( )

inline

Definition at line 2696 of file FEProblemBase.h.

2696{ return _petsc_option_data_base; }

Referenced by EigenProblemSolve::initialSetup(), and Moose::PetscSupport::PetscOptionsScope::PetscOptionsScope().

◆ petscOptionsInserted()

bool & FEProblemBase::petscOptionsInserted ( )

inline

If PETSc options are already inserted.

Definition at line 2693 of file FEProblemBase.h.

2693{ return _is_petsc_options_inserted; }

Referenced by EigenProblemSolve::initialSetup().

◆ possiblyRebuildGeomSearchPatches()

void FEProblemBase::possiblyRebuildGeomSearchPatches ( )

virtual

Definition at line 8825 of file FEProblemBase.C.

{
  if (_displaced_problem) // Only need to do this if things are moving...
  {
    TIME_SECTION("possiblyRebuildGeomSearchPatches", 5, "Rebuilding Geometric Search Patches");
 
    switch (_mesh.getPatchUpdateStrategy())
    {
      case Moose::Never:
        break;
      case Moose::Iteration:
        // Update the list of ghosted elements at the start of the time step
        _geometric_search_data.updateGhostedElems();
        _mesh.updateActiveSemiLocalNodeRange(_ghosted_elems);
 
        _displaced_problem->geomSearchData().updateGhostedElems();
        _displaced_mesh->updateActiveSemiLocalNodeRange(_ghosted_elems);
 
        // The commands below ensure that the sparsity of the Jacobian matrix is
        // augmented at the start of the time step using neighbor nodes from the end
        // of the previous time step.
 
        reinitBecauseOfGhostingOrNewGeomObjects();
 
        // This is needed to reinitialize PETSc output
        initPetscOutputAndSomeSolverSettings();
 
        break;
 
      case Moose::Auto:
      {
        Real max = _displaced_problem->geomSearchData().maxPatchPercentage();
        _communicator.max(max);
 
        // If we haven't moved very far through the patch
        if (max < 0.4)
          break;
      }
        libmesh_fallthrough();
 
      // Let this fall through if things do need to be updated...
      case Moose::Always:
        // Flush output here to see the message before the reinitialization, which could take a
        // while
        _console << "\n\nUpdating geometric search patches\n" << std::endl;
 
        _geometric_search_data.clearNearestNodeLocators();
        _mesh.updateActiveSemiLocalNodeRange(_ghosted_elems);
 
        _displaced_problem->geomSearchData().clearNearestNodeLocators();
        _displaced_mesh->updateActiveSemiLocalNodeRange(_ghosted_elems);
 
        reinitBecauseOfGhostingOrNewGeomObjects();
 
        // This is needed to reinitialize PETSc output
        initPetscOutputAndSomeSolverSettings();
    }
  }
}

Referenced by solve().

◆ postExecute()

void FEProblemBase::postExecute ( )

virtual

Method called at the end of the simulation.

Definition at line 6359 of file FEProblemBase.C.

{
  const auto & multi_apps = _multi_apps.getActiveObjects();
 
  for (const auto & multi_app : multi_apps)
    multi_app->postExecute();
}

Referenced by Eigenvalue::execute(), SteadyBase::execute(), TransientBase::execute(), and MFEMSteady::execute().

◆ predictorCleanup()

void FEProblemBase::predictorCleanup ( NumericVector< libMesh::Number > & ghosted_solution )

virtual

Perform cleanup tasks after application of predictor to solution vector.

Parameters

ghosted_solution Ghosted solution vector

Definition at line 8717 of file FEProblemBase.C.

8718{

8719}

Referenced by NonlinearSystemBase::setInitialSolution().

◆ prepare() [1/2]

void FEProblemBase::prepare	(	const Elem *	elem,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 1913 of file FEProblemBase.C.

{
  for (const auto i : index_range(_solver_systems))
  {
    _assembly[tid][i]->reinit(elem);
    _solver_systems[i]->prepare(tid);
 
    if (i < _num_nl_sys)
    {
      // This method is called outside of residual/Jacobian callbacks during initial condition
      // evaluation
      if ((!_has_jacobian || !_const_jacobian) && currentlyComputingJacobian())
        _assembly[tid][i]->prepareJacobianBlock();
      _assembly[tid][i]->prepareResidual();
      if (_has_nonlocal_coupling && currentlyComputingJacobian())
        _assembly[tid][i]->prepareNonlocal();
    }
  }
  _aux->prepare(tid);
 
  if (_displaced_problem &&
      // _reinit_displaced_neighbor applies to interface type objects which will do computations
      // based on both elem and neighbor. Consequently, despite what you might think by its name, we
      // must make sure we prepare the displaced elem
      (_reinit_displaced_elem || _reinit_displaced_face || _reinit_displaced_neighbor))
  {
    _displaced_problem->prepare(_displaced_mesh->elemPtr(elem->id()), tid);
    if (_has_nonlocal_coupling)
      _displaced_problem->prepareNonlocal(tid);
  }
}

Referenced by NodalPatchRecovery::compute(), ComputeElemDampingThread::onElement(), ComputeIndicatorThread::onElement(), ComputeMarkerThread::onElement(), ComputeMaterialsObjectThread::onElement(), ComputeUserObjectsThread::onElement(), and ComputeInitialConditionThread::operator()().

◆ prepare() [2/2]

void FEProblemBase::prepare	(	const Elem *	elem,
		unsigned int	ivar,
		unsigned int	jvar,
		const std::vector< dof_id_type > &	dof_indices,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 1957 of file FEProblemBase.C.

{
  for (const auto i : index_range(_nl))
  {
    _assembly[tid][i]->reinit(elem);
    _nl[i]->prepare(tid);
  }
 
  _aux->prepare(tid);
  const auto current_nl_sys_num = _current_nl_sys->number();
  _assembly[tid][current_nl_sys_num]->prepareBlock(ivar, jvar, dof_indices);
  if (_has_nonlocal_coupling)
    if (_nonlocal_cm[current_nl_sys_num](ivar, jvar) != 0)
    {
      MooseVariableFEBase & jv = _current_nl_sys->getVariable(tid, jvar);
      _assembly[tid][current_nl_sys_num]->prepareBlockNonlocal(
          ivar, jvar, dof_indices, jv.allDofIndices());
    }
 
  if (_displaced_problem && (_reinit_displaced_elem || _reinit_displaced_face))
  {
    _displaced_problem->prepare(_displaced_mesh->elemPtr(elem->id()), ivar, jvar, dof_indices, tid);
    if (_has_nonlocal_coupling)
      if (_nonlocal_cm[current_nl_sys_num](ivar, jvar) != 0)
      {
        MooseVariableFEBase & jv = _current_nl_sys->getVariable(tid, jvar);
        _displaced_problem->prepareBlockNonlocal(ivar, jvar, dof_indices, jv.allDofIndices(), tid);
      }
  }
}

◆ prepareAssembly()

void FEProblemBase::prepareAssembly ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 2032 of file FEProblemBase.C.

{
  _assembly[tid][_current_nl_sys->number()]->prepare();
  if (_has_nonlocal_coupling)
    _assembly[tid][_current_nl_sys->number()]->prepareNonlocal();
 
  if (_displaced_problem &&
      (_reinit_displaced_elem || _reinit_displaced_face || _reinit_displaced_neighbor))
  {
    _displaced_problem->prepareAssembly(tid);
    if (_has_nonlocal_coupling)
      _displaced_problem->prepareNonlocal(tid);
  }
}

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), NonlinearSystemBase::reinitNodeFace(), and NonlinearSystemBase::setConstraintSecondaryValues().

◆ prepareAssemblyNeighbor()

void FEProblemBase::prepareAssemblyNeighbor ( const THREAD_ID tid )

virtual

Begin a fresh neighbor accumulation phase by sizing and zeroing the neighbor blocks.

Definition at line 2048 of file FEProblemBase.C.

{
  _assembly[tid][_current_nl_sys->number()]->prepareNeighbor();
 
  if (_displaced_problem && (_reinit_displaced_face || _reinit_displaced_neighbor))
    _displaced_problem->prepareAssemblyNeighbor(tid);
}

Referenced by NonlinearSystemBase::constraintJacobians().

◆ prepareFace()

void FEProblemBase::prepareFace	(	const Elem *	elem,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 1946 of file FEProblemBase.C.

{
  for (auto & nl : _nl)
    nl->prepareFace(tid, true);
  _aux->prepareFace(tid, false);
 
  if (_displaced_problem && (_reinit_displaced_elem || _reinit_displaced_face))
    _displaced_problem->prepareFace(_displaced_mesh->elemPtr(elem->id()), tid);
}

Referenced by ComputeUserObjectsThread::onInterface(), and ComputeUserObjectsThread::onInternalSide().

◆ prepareFaceShapes()

void FEProblemBase::prepareFaceShapes	(	unsigned int	var,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 2316 of file FEProblemBase.C.

{
  _assembly[tid][_current_nl_sys->number()]->copyFaceShapes(var);
}

Referenced by ComputeUserObjectsThread::onBoundary().

◆ prepareKokkosMaterials()

void FEProblemBase::prepareKokkosMaterials ( const std::unordered_set< unsigned int > & consumer_needed_mat_props )

◆ prepareMaterials()

void FEProblemBase::prepareMaterials	(	const std::unordered_set< unsigned int > &	consumer_needed_mat_props,
		const SubdomainID	blk_id,
		const THREAD_ID	tid
	)

Add the MooseVariables and the material properties that the current materials depend on to the dependency list.

Parameters

consumer_needed_mat_props	The material properties needed by consumer objects (other than the materials themselves)
blk_id	The subdomain ID for which we are preparing our list of needed vars and props
tid	The thread ID we are preparing the requirements for

This MUST be done after the moose variable dependency list has been set for all the other objects using the setActiveElementalMooseVariables API!

Definition at line 4315 of file FEProblemBase.C.

{
  std::set<MooseVariableFEBase *> needed_moose_vars;
  std::unordered_set<unsigned int> needed_mat_props;
 
  if (_all_materials.hasActiveBlockObjects(blk_id, tid))
  {
    _all_materials.updateVariableDependency(needed_moose_vars, tid);
    _all_materials.updateBlockMatPropDependency(blk_id, needed_mat_props, tid);
  }
 
  const auto & ids = _mesh.getSubdomainBoundaryIds(blk_id);
  for (const auto id : ids)
  {
    _materials.updateBoundaryVariableDependency(id, needed_moose_vars, tid);
    _materials.updateBoundaryMatPropDependency(id, needed_mat_props, tid);
  }
 
  const auto & current_active_elemental_moose_variables = getActiveElementalMooseVariables(tid);
  needed_moose_vars.insert(current_active_elemental_moose_variables.begin(),
                           current_active_elemental_moose_variables.end());
 
  needed_mat_props.insert(consumer_needed_mat_props.begin(), consumer_needed_mat_props.end());
 
  setActiveElementalMooseVariables(needed_moose_vars, tid);
  setActiveMaterialProperties(needed_mat_props, tid);
}

Referenced by ComputeIndicatorThread::subdomainChanged(), ComputeMarkerThread::subdomainChanged(), and ComputeUserObjectsThread::subdomainChanged().

◆ prepareNeighborShapes()

void FEProblemBase::prepareNeighborShapes	(	unsigned int	var,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 2322 of file FEProblemBase.C.

{
  _assembly[tid][_current_nl_sys->number()]->copyNeighborShapes(var);
}

◆ preparePRefinement()

void SubProblem::preparePRefinement ( )

inherited

Prepare DofMap and Assembly classes with our p-refinement information.

Definition at line 1337 of file SubProblem.C.

{
  for (const auto tid : make_range(numThreads()))
    for (const auto s : make_range(numNonlinearSystems()))
      assembly(tid, s).preparePRefinement();
}

Referenced by init().

◆ prepareShapes()

void FEProblemBase::prepareShapes	(	unsigned int	var,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 2310 of file FEProblemBase.C.

{
  _assembly[tid][_current_nl_sys->number()]->copyShapes(var);
}

Referenced by ComputeUserObjectsThread::onElement().

◆ preserveMatrixSparsityPattern()

bool FEProblemBase::preserveMatrixSparsityPattern ( ) const

inline

Will return True if the executioner in use requires preserving the sparsity pattern of the matrices being formed during the solve.

This is usually the Jacobian.

Definition at line 2452 of file FEProblemBase.h.

2452{ return _preserve_matrix_sparsity_pattern; };

◆ projectFunctionOnCustomRange()

void FEProblemBase::projectFunctionOnCustomRange	(	ConstElemRange &	elem_range,
		Number(*)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &)	func,
		Gradient(*)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &)	func_grad,
		const libMesh::Parameters &	params,
		const std::vector< VariableName > &	target_vars
	)

Project a function onto a range of elements for a given variable.

Parameters

elem_range	Element range to project on
func	Function to project
func_grad	Gradient of the function
params	Parameters to pass to the function
target_vars	variable names to project

Definition at line 4025 of file FEProblemBase.C.

{
  mooseAssert(!Threads::in_threads,
              "We're performing a projection based on data from just the thread 0 variable, so any "
              "modifications to the variable solution must have been thread joined already");
 
  std::unordered_map<unsigned int, std::vector<unsigned int>> sys_to_var_nums;
 
  for (const auto & target_var : target_vars)
  {
    const auto sn = systemNumForVariable(target_var);
    const auto & var = getStandardVariable(0, target_var);
    sys_to_var_nums[sn].push_back(var.number());
  }
 
  for (const auto & [sys_num, var_nums] : sys_to_var_nums)
  {
    System & libmesh_sys = getSystemBase(sys_num).system();
    libmesh_sys.project_solution(func, func_grad, params, elem_range, var_nums);
  }
}

Referenced by ElementSubdomainModifierBase::extrapolatePolynomial().

◆ projectInitialConditionOnCustomRange()

void FEProblemBase::projectInitialConditionOnCustomRange	(	libMesh::ConstElemRange &	elem_range,
		ConstBndNodeRange &	bnd_node_range,
		const std::optional< std::set< VariableName > > &	target_vars = `std::nullopt`
	)

Project initial conditions for custom elem_range and bnd_node_range This is needed when elements/boundary nodes are added to a specific subdomain at an intermediate step.

Parameters

elem_range	Element range to project on
bnd_node_range	Boundary node range to project on
target_vars	Set of variable names to project ICs

Definition at line 3950 of file FEProblemBase.C.

{
  if (target_vars)
  {
    ComputeInitialConditionThread cic(*this, &(*target_vars));
    Threads::parallel_reduce(elem_range, cic, numThreads());
  }
  else
  {
    ComputeInitialConditionThread cic(*this);
    Threads::parallel_reduce(elem_range, cic, numThreads());
  }
 
  // Need to close the solution vector here so that boundary ICs take precendence
  for (auto & nl : _nl)
    nl->solution().close();
  _aux->solution().close();
 
  if (target_vars)
  {
    ComputeBoundaryInitialConditionThread cbic(*this, &(*target_vars));
    Threads::parallel_reduce(bnd_nodes, cbic, numThreads());
  }
  else
  {
    ComputeBoundaryInitialConditionThread cbic(*this);
    Threads::parallel_reduce(bnd_nodes, cbic, numThreads());
  }
 
  for (auto & nl : _nl)
    nl->solution().close();
  _aux->solution().close();
 
  // Also, load values into the SCALAR dofs
  // Note: We assume that all SCALAR dofs are on the
  // processor with highest ID
  if (processor_id() == (n_processors() - 1) && _scalar_ics.hasActiveObjects())
  {
    const auto & ics = _scalar_ics.getActiveObjects();
    for (const auto & ic : ics)
    {
      MooseVariableScalar & var = ic->variable();
 
      if (target_vars && !target_vars->count(var.name()))
        continue;
 
      var.reinit();
 
      DenseVector<Number> vals(var.order());
      ic->compute(vals);
 
      const unsigned int n_scalar_dofs = var.dofIndices().size();
      for (unsigned int i = 0; i < n_scalar_dofs; i++)
      {
        const auto global_index = var.dofIndices()[i];
        var.sys().solution().set(global_index, vals(i));
        var.setValue(i, vals(i));
      }
    }
  }
 
  for (auto & nl : _nl)
  {
    nl->solution().close();
    nl->solution().localize(*nl->system().current_local_solution, nl->dofMap().get_send_list());
  }
 
  _aux->solution().close();
  _aux->solution().localize(*_aux->sys().current_local_solution, _aux->dofMap().get_send_list());
}

Referenced by ElementSubdomainModifierBase::applyIC(), and ActivateElementsUserObjectBase::initSolutions().

◆ projectSolution()

void FEProblemBase::projectSolution ( )

Definition at line 3884 of file FEProblemBase.C.

{
  TIME_SECTION("projectSolution", 2, "Projecting Initial Solutions")
 
  FloatingPointExceptionGuard fpe_guard(_app);
 
  ComputeInitialConditionThread cic(*this);
  Threads::parallel_reduce(getCurrentAlgebraicElementRange(), cic, numThreads());
 
  if (haveFV())
  {
    using ElemInfoRange = StoredRange<MooseMesh::const_elem_info_iterator, const ElemInfo *>;
    ElemInfoRange elem_info_range(_mesh.ownedElemInfoBegin(), _mesh.ownedElemInfoEnd());
 
    ComputeFVInitialConditionThread cfvic(*this);
    Threads::parallel_reduce(elem_info_range, cfvic, numThreads());
  }
 
  // Need to close the solution vector here so that boundary ICs take precendence
  for (auto & nl : _nl)
    nl->solution().close();
  _aux->solution().close();
 
  // now run boundary-restricted initial conditions
  ComputeBoundaryInitialConditionThread cbic(*this);
  Threads::parallel_reduce(getCurrentAlgebraicBndNodeRange(), cbic, numThreads());
 
  for (auto & nl : _nl)
    nl->solution().close();
  _aux->solution().close();
 
  // Also, load values into the SCALAR dofs
  // Note: We assume that all SCALAR dofs are on the
  // processor with highest ID
  if (processor_id() == (n_processors() - 1) && _scalar_ics.hasActiveObjects())
  {
    const auto & ics = _scalar_ics.getActiveObjects();
    for (const auto & ic : ics)
    {
      MooseVariableScalar & var = ic->variable();
      var.reinit();
 
      DenseVector<Number> vals(var.order());
      ic->compute(vals);
 
      const unsigned int n_scalar_dofs = var.dofIndices().size();
      for (unsigned int i = 0; i < n_scalar_dofs; i++)
      {
        const auto global_index = var.dofIndices()[i];
        var.sys().solution().set(global_index, vals(i));
        var.setValue(i, vals(i));
      }
    }
  }
 
  for (auto & sys : _solver_systems)
  {
    sys->solution().close();
    sys->solution().localize(*sys->system().current_local_solution, sys->dofMap().get_send_list());
  }
 
  _aux->solution().close();
  _aux->solution().localize(*_aux->sys().current_local_solution, _aux->dofMap().get_send_list());
}

Referenced by initialAdaptMesh().

◆ queryParam()

template<typename T >

const T * MooseBase::queryParam ( const std::string & name ) const

inherited

Query a parameter for the object.

If a parameter of the given name and type does not exist or if the parameter is not valid, nullptr will be returned

Parameters

name	The name of the parameter

Returns: A pointer to the parameter value, if it exists

Definition at line 413 of file MooseBase.h.

{
  return _pars.queryParam<T>(name);
}

Referenced by MFEMExecutedObject::getRequestedItems(), and MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver().

◆ registerInvalidSolutionInternal()

InvalidSolutionID SolutionInvalidInterface::registerInvalidSolutionInternal	(	const std::string &	message,
		const bool	warning
	)		const

protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

{
  return moose::internal::getSolutionInvalidityRegistry().registerInvalidity(
      _si_moose_base.type(), message, warning);
}

◆ registerRandomInterface()

void FEProblemBase::registerRandomInterface	(	RandomInterface &	random_interface,
		const std::string &	name
	)

Definition at line 9676 of file FEProblemBase.C.

{
  auto insert_pair = moose_try_emplace(
      _random_data_objects, name, std::make_unique<RandomData>(*this, random_interface));
 
  auto random_data_ptr = insert_pair.first->second.get();
  random_interface.setRandomDataPointer(random_data_ptr);
}

Referenced by RandomInterface::setRandomResetFrequency().

◆ registerRestartableDataOnApp()

RestartableDataValue & Restartable::registerRestartableDataOnApp	(	std::unique_ptr< RestartableDataValue >	data,
		THREAD_ID	tid
	)		const

privateinherited

Helper function for actually registering the restartable data.

Definition at line 63 of file Restartable.C.

{
  return _restartable_app.registerRestartableData(
      std::move(data), tid, _restartable_read_only, _metaname);
}

Referenced by Restartable::declareRestartableDataHelper().

◆ registerRestartableNameWithFilterOnApp()

void Restartable::registerRestartableNameWithFilterOnApp	(	const std::string &	name,
		Moose::RESTARTABLE_FILTER	filter
	)

privateinherited

Helper function for actually registering the restartable data.

Definition at line 71 of file Restartable.C.

{
  _restartable_app.registerRestartableNameWithFilter(name, filter);
}

Referenced by Restartable::declareRecoverableData().

◆ registerTimedSection() [1/2]

PerfID PerfGraphInterface::registerTimedSection	(	const std::string &	section_name,
		const unsigned int	level
	)		const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns: The ID of the section - use when starting timing

Definition at line 61 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

◆ registerTimedSection() [2/2]

PerfID PerfGraphInterface::registerTimedSection	(	const std::string &	section_name,
		const unsigned int	level,
		const std::string &	live_message,
		const bool	print_dots = `true`
	)		const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)
live_message	The message to be printed to the screen during execution
print_dots	Whether or not progress dots should be printed for this section

Returns: The ID of the section - use when starting timing

Definition at line 72 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(
        timedSectionName(section_name), level, live_message, print_dots);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

◆ registerUnfilledFunctorRequest()

template<typename T >

void SubProblem::registerUnfilledFunctorRequest	(	T *	functor_interface,
		const std::string &	functor_name,
		const THREAD_ID	tid
	)

inherited

Register an unfulfilled functor request.

◆ reinitBecauseOfGhostingOrNewGeomObjects()

void FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects ( bool mortar_changed = false )

protected

Call when it is possible that the needs for ghosted elements has changed.

Parameters

mortar_changed Whether an update of mortar data has been requested since the last EquationSystems (re)initialization

Definition at line 5782 of file FEProblemBase.C.

{
  TIME_SECTION("reinitBecauseOfGhostingOrNewGeomObjects",
               3,
               "Reinitializing Because of Geometric Search Objects");
 
  // Need to see if _any_ processor has ghosted elems or geometry objects.
  bool needs_reinit = !_ghosted_elems.empty();
  needs_reinit = needs_reinit || !_geometric_search_data._nearest_node_locators.empty() ||
                 (_mortar_data->hasObjects() && mortar_changed);
  needs_reinit =
      needs_reinit || (_displaced_problem &&
                       (!_displaced_problem->geomSearchData()._nearest_node_locators.empty() ||
                        (_mortar_data->hasDisplacedObjects() && mortar_changed)));
  _communicator.max(needs_reinit);
 
  if (needs_reinit)
  {
    // Call reinit to get the ghosted vectors correct now that some geometric search has been done
    es().reinit();
 
    if (_displaced_mesh)
      _displaced_problem->es().reinit();
  }
}

Referenced by meshChanged(), possiblyRebuildGeomSearchPatches(), and updateMortarMesh().

◆ reinitDirac()

bool FEProblemBase::reinitDirac	(	const Elem *	elem,
		const THREAD_ID	tid
	)

overridevirtual

Returns true if the Problem has Dirac kernels it needs to compute on elem.

The maximum number of qps can rise if several Dirac points are added to a single element. In that case we need to resize the zeros to compensate.

Implements SubProblem.

Definition at line 2361 of file FEProblemBase.C.

{
  std::vector<Point> & points = _dirac_kernel_info.getPoints()[elem].first;
 
  unsigned int n_points = points.size();
 
  if (n_points)
  {
    if (n_points > _max_qps)
    {
      _max_qps = n_points;
 
      unsigned int max_qpts = getMaxQps();
      for (unsigned int tid = 0; tid < numThreads(); ++tid)
      {
        // the highest available order in libMesh is 43
        _scalar_zero[tid].resize(libMesh::FORTYTHIRD, 0);
        _zero[tid].resize(max_qpts, 0);
        _grad_zero[tid].resize(max_qpts, RealGradient(0.));
        _second_zero[tid].resize(max_qpts, RealTensor(0.));
        _vector_zero[tid].resize(max_qpts, RealGradient(0.));
        _vector_curl_zero[tid].resize(max_qpts, RealGradient(0.));
      }
    }
 
    for (const auto i : index_range(_nl))
    {
      _assembly[tid][i]->reinitAtPhysical(elem, points);
      _nl[i]->prepare(tid);
    }
    _aux->prepare(tid);
 
    reinitElem(elem, tid);
  }
 
  _assembly[tid][_current_nl_sys->number()]->prepare();
  if (_has_nonlocal_coupling)
    _assembly[tid][_current_nl_sys->number()]->prepareNonlocal();
 
  bool have_points = n_points > 0;
  if (_displaced_problem && (_reinit_displaced_elem))
  {
    have_points |= _displaced_problem->reinitDirac(_displaced_mesh->elemPtr(elem->id()), tid);
    if (_has_nonlocal_coupling)
      _displaced_problem->prepareNonlocal(tid);
  }
 
  return have_points;
}

Referenced by ComputeDiracThread::onElement().

◆ reinitElem()

void FEProblemBase::reinitElem	(	const Elem *	elem,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 2416 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    sys->reinitElem(elem, tid);
  _aux->reinitElem(elem, tid);
 
  if (_displaced_problem && _reinit_displaced_elem)
    _displaced_problem->reinitElem(_displaced_mesh->elemPtr(elem->id()), tid);
}

Referenced by NodalPatchRecovery::compute(), ComputeElemDampingThread::onElement(), ComputeIndicatorThread::onElement(), ComputeMarkerThread::onElement(), ComputeMaterialsObjectThread::onElement(), ComputeUserObjectsThread::onElement(), ComputeInitialConditionThread::operator()(), reinitDirac(), and reinitElemPhys().

◆ reinitElemFace() [1/2]

void FEProblemBase::reinitElemFace	(	const Elem *	elem,
		unsigned int	side,
		BoundaryID	,
		const THREAD_ID	tid
	)

Definition at line 2448 of file FEProblemBase.C.

{
  mooseDeprecated(
      "reinitElemFace with a BoundaryID argument is deprecated because the boundary id was never "
      "used. Please call reinitElemFace without the BoundaryID argument instead");
 
  reinitElemFace(elem, side, tid);
}

Referenced by ComputeMaterialsObjectThread::onBoundary(), ComputeUserObjectsThread::onBoundary(), ComputeMaterialsObjectThread::onInterface(), NonlinearThread::prepareFace(), and reinitElemFace().

◆ reinitElemFace() [2/2]

void FEProblemBase::reinitElemFace	(	const Elem *	elem,
		unsigned int	side,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 2461 of file FEProblemBase.C.

{
  for (const auto i : index_range(_solver_systems))
  {
    _assembly[tid][i]->reinit(elem, side);
    _solver_systems[i]->reinitElemFace(elem, side, tid);
  }
  _aux->reinitElemFace(elem, side, tid);
 
  if (_displaced_problem && _reinit_displaced_face)
    _displaced_problem->reinitElemFace(_displaced_mesh->elemPtr(elem->id()), side, tid);
}

◆ reinitElemFaceRef()

void FEProblemBase::reinitElemFaceRef	(	const Elem *	elem,
		unsigned int	side,
		Real	tolerance,
		const std::vector< Point > *const	pts,
		const std::vector< Real > *const	weights = `nullptr`,
		const THREAD_ID	tid = `0`
	)

overridevirtual

reinitialize FE objects on a given element on a given side at a given set of reference points and then compute variable data.

Note that this method makes no assumptions about what's been called beforehand, e.g. you don't have to call some prepare method before this one. This is an all-in-one reinit

Reimplemented from SubProblem.

Definition at line 10066 of file FEProblemBase.C.

{
  SubProblem::reinitElemFaceRef(elem, side, tolerance, pts, weights, tid);
 
  if (_displaced_problem)
    _displaced_problem->reinitElemFaceRef(
        _displaced_mesh->elemPtr(elem->id()), side, tolerance, pts, weights, tid);
}

Referenced by Moose::Mortar::loopOverMortarSegments().

◆ reinitElemNeighborAndLowerD()

void FEProblemBase::reinitElemNeighborAndLowerD	(	const Elem *	elem,
		unsigned int	side,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 2580 of file FEProblemBase.C.

{
  reinitNeighbor(elem, side, tid);
 
  const Elem * lower_d_elem = _mesh.getLowerDElem(elem, side);
  if (lower_d_elem && _mesh.interiorLowerDBlocks().count(lower_d_elem->subdomain_id()) > 0)
    reinitLowerDElem(lower_d_elem, tid);
  else
  {
    // with mesh refinement, lower-dimensional element might be defined on neighbor side
    auto & neighbor = _assembly[tid][0]->neighbor();
    auto & neighbor_side = _assembly[tid][0]->neighborSide();
    const Elem * lower_d_elem_neighbor = _mesh.getLowerDElem(neighbor, neighbor_side);
    if (lower_d_elem_neighbor &&
        _mesh.interiorLowerDBlocks().count(lower_d_elem_neighbor->subdomain_id()) > 0)
    {
      auto qps = _assembly[tid][0]->qPointsFaceNeighbor().stdVector();
      std::vector<Point> reference_points;
      FEMap::inverse_map(
          lower_d_elem_neighbor->dim(), lower_d_elem_neighbor, qps, reference_points);
      reinitLowerDElem(lower_d_elem_neighbor, tid, &reference_points);
    }
  }
 
  if (_displaced_problem && (_reinit_displaced_face || _reinit_displaced_neighbor))
    _displaced_problem->reinitElemNeighborAndLowerD(
        _displaced_mesh->elemPtr(elem->id()), side, tid);
}

Referenced by ComputeMaterialsObjectThread::onInternalSide(), and NonlinearThread::onInternalSide().

◆ reinitElemPhys()

void FEProblemBase::reinitElemPhys	(	const Elem *	elem,
		const std::vector< Point > &	phys_points_in_elem,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 2427 of file FEProblemBase.C.

{
  mooseAssert(_mesh.queryElemPtr(elem->id()) == elem,
              "Are you calling this method with a displaced mesh element?");
 
  for (const auto i : index_range(_solver_systems))
  {
    _assembly[tid][i]->reinitAtPhysical(elem, phys_points_in_elem);
    _solver_systems[i]->prepare(tid);
    _assembly[tid][i]->prepare();
    if (_has_nonlocal_coupling)
      _assembly[tid][i]->prepareNonlocal();
  }
  _aux->prepare(tid);
 
  reinitElem(elem, tid);
}

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute().

◆ reinitFVFace()

void SubProblem::reinitFVFace	(	const THREAD_ID	tid,
		const FaceInfo &	fi
	)

inherited

reinitialize the finite volume assembly data for the provided face and thread

Definition at line 1289 of file SubProblem.C.

{
  for (const auto nl : make_range(numNonlinearSystems()))
    assembly(tid, nl).reinitFVFace(fi);
}

◆ reinitGeomSearch()

void SubProblem::reinitGeomSearch ( )

inherited

reinitialize this object's geometric search data, e.g.

do things like clear and re-add quadrature nodes

Definition at line 1373 of file SubProblem.C.

{
  geomSearchData().reinit();
}

◆ reinitKokkosMaterials()

void FEProblemBase::reinitKokkosMaterials ( )

◆ reinitLowerDElem()

void FEProblemBase::reinitLowerDElem	(	const Elem *	lower_d_elem,
		const THREAD_ID	tid,
		const std::vector< Point > *const	pts = `nullptr`,
		const std::vector< Real > *const	weights = `nullptr`
	)

overridevirtual

Reimplemented from SubProblem.

Definition at line 2475 of file FEProblemBase.C.

{
  SubProblem::reinitLowerDElem(lower_d_elem, tid, pts, weights);
 
  if (_displaced_problem && _displaced_mesh)
    _displaced_problem->reinitLowerDElem(
        _displaced_mesh->elemPtr(lower_d_elem->id()), tid, pts, weights);
}

Referenced by ComputeUserObjectsThread::onBoundary(), NonlinearThread::prepareFace(), and reinitElemNeighborAndLowerD().

◆ reinitMaterials()

void FEProblemBase::reinitMaterials	(	SubdomainID	blk_id,
		const THREAD_ID	tid,
		bool	swap_stateful = `true`
	)

Definition at line 4346 of file FEProblemBase.C.

{
  if (hasActiveMaterialProperties(tid))
  {
    auto && elem = _assembly[tid][0]->elem();
    unsigned int n_points = _assembly[tid][0]->qRule()->n_points();
 
    auto & material_data = _material_props.getMaterialData(tid);
    material_data.resize(n_points);
 
    // Only swap if requested
    if (swap_stateful)
      material_data.swap(*elem);
 
    if (_discrete_materials.hasActiveBlockObjects(blk_id, tid))
      material_data.reset(_discrete_materials.getActiveBlockObjects(blk_id, tid));
 
    if (_materials.hasActiveBlockObjects(blk_id, tid))
      material_data.reinit(_materials.getActiveBlockObjects(blk_id, tid));
  }
}

Referenced by NodalPatchRecovery::compute(), ComputeDiracThread::onElement(), ComputeIndicatorThread::onElement(), ComputeMarkerThread::onElement(), and ComputeUserObjectsThread::onElement().

◆ reinitMaterialsBoundary()

void FEProblemBase::reinitMaterialsBoundary	(	BoundaryID	boundary_id,
		const THREAD_ID	tid,
		bool	swap_stateful = `true`,
		const std::deque< MaterialBase * > *	reinit_mats = `nullptr`
	)

reinit materials on a boundary

Parameters

boundary_id	The boundary on which to reinit corresponding materials
tid	The thread id
swap_stateful	Whether to swap stateful material properties between `MaterialData` and `MaterialPropertyStorage`
execute_stateful	Whether to execute material objects that have stateful properties. This should be `false` when for example executing material objects for mortar contexts in which stateful properties don't make sense
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4491 of file FEProblemBase.C.

{
  if (hasActiveMaterialProperties(tid) && needBoundaryMaterialOnSide(boundary_id, tid))
  {
    auto && elem = _assembly[tid][0]->elem();
    unsigned int side = _assembly[tid][0]->side();
    unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();
 
    auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
    bnd_material_data.resize(n_points);
 
    if (swap_stateful && !bnd_material_data.isSwapped())
      bnd_material_data.swap(*elem, side);
 
    if (_discrete_materials.hasActiveBoundaryObjects(boundary_id, tid))
      bnd_material_data.reset(_discrete_materials.getActiveBoundaryObjects(boundary_id, tid));
 
    if (reinit_mats)
      bnd_material_data.reinit(*reinit_mats);
    else if (_materials.hasActiveBoundaryObjects(boundary_id, tid))
      bnd_material_data.reinit(_materials.getActiveBoundaryObjects(boundary_id, tid));
  }
}

Referenced by Moose::Mortar::loopOverMortarSegments(), ComputeUserObjectsThread::onBoundary(), ComputeUserObjectsThread::onInterface(), NonlinearThread::onInterface(), and NonlinearThread::prepareFace().

◆ reinitMaterialsFace()

void FEProblemBase::reinitMaterialsFace	(	SubdomainID	blk_id,
		const THREAD_ID	tid,
		bool	swap_stateful = `true`,
		const std::deque< MaterialBase * > *	reinit_mats = `nullptr`
	)

reinit materials on element faces

Parameters

blk_id	The subdomain on which the element owning the face lives
tid	The thread id
swap_stateful	Whether to swap stateful material properties between `MaterialData` and `MaterialPropertyStorage`
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4369 of file FEProblemBase.C.

{
  // we reinit more often than needed here because we dont have a way to check whether
  // we need to compute the face materials on a particular (possibly external) face
  if (hasActiveMaterialProperties(tid))
  {
    auto && elem = _assembly[tid][0]->elem();
    unsigned int side = _assembly[tid][0]->side();
    unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();
 
    auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
    bnd_material_data.resize(n_points);
 
    if (swap_stateful && !bnd_material_data.isSwapped())
      bnd_material_data.swap(*elem, side);
 
    if (_discrete_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
      bnd_material_data.reset(
          _discrete_materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
 
    if (reinit_mats)
      bnd_material_data.reinit(*reinit_mats);
    else if (_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
      bnd_material_data.reinit(
          _materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
  }
}

Referenced by Moose::Mortar::loopOverMortarSegments(), ComputeIndicatorThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), NonlinearThread::onInternalSide(), and NonlinearThread::prepareFace().

◆ reinitMaterialsFaceOnBoundary()

void FEProblemBase::reinitMaterialsFaceOnBoundary	(	const BoundaryID	boundary_id,
		const SubdomainID	blk_id,
		const THREAD_ID	tid,
		const bool	swap_stateful = `true`,
		const std::deque< MaterialBase * > *const	reinit_mats = `nullptr`
	)

reinit materials on element faces on a boundary (internal or external) This specific routine helps us not reinit when don't need to

Parameters

boundary_id	The boundary on which the face belongs
blk_id	The block id to which the element (who owns the face) belong
tid	The thread id
swap_stateful	Whether to swap stateful material properties between `MaterialData` and `MaterialPropertyStorage`
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4401 of file FEProblemBase.C.

{
  if (hasActiveMaterialProperties(tid) && (needBoundaryMaterialOnSide(boundary_id, tid) ||
                                           needInterfaceMaterialOnSide(boundary_id, tid) ||
                                           needInternalNeighborSideMaterial(blk_id, tid)))
  {
    const auto * const elem = _assembly[tid][0]->elem();
    unsigned int side = _assembly[tid][0]->side();
    unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();
 
    auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
    bnd_material_data.resize(n_points);
 
    if (swap_stateful && !bnd_material_data.isSwapped())
      bnd_material_data.swap(*elem, side);
 
    if (_discrete_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
      bnd_material_data.reset(
          _discrete_materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
 
    if (reinit_mats)
      bnd_material_data.reinit(*reinit_mats);
    else if (_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
      bnd_material_data.reinit(
          _materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
  }
}

Referenced by ComputeUserObjectsThread::onBoundary(), ComputeUserObjectsThread::onInterface(), NonlinearThread::onInterface(), and NonlinearThread::prepareFace().

◆ reinitMaterialsInterface()

void FEProblemBase::reinitMaterialsInterface	(	BoundaryID	boundary_id,
		const THREAD_ID	tid,
		bool	swap_stateful = `true`
	)

Definition at line 4519 of file FEProblemBase.C.

{
  if (hasActiveMaterialProperties(tid) && needInterfaceMaterialOnSide(boundary_id, tid))
  {
    const Elem * const & elem = _assembly[tid][0]->elem();
    unsigned int side = _assembly[tid][0]->side();
    unsigned int n_points = _assembly[tid][0]->qRuleFace()->n_points();
 
    auto & bnd_material_data = _bnd_material_props.getMaterialData(tid);
    bnd_material_data.resize(n_points);
 
    if (swap_stateful && !bnd_material_data.isSwapped())
      bnd_material_data.swap(*elem, side);
 
    if (_interface_materials.hasActiveBoundaryObjects(boundary_id, tid))
      bnd_material_data.reinit(_interface_materials.getActiveBoundaryObjects(boundary_id, tid));
  }
}

Referenced by ComputeUserObjectsThread::onInterface(), and NonlinearThread::onInterface().

◆ reinitMaterialsNeighbor()

void FEProblemBase::reinitMaterialsNeighbor	(	SubdomainID	blk_id,
		const THREAD_ID	tid,
		bool	swap_stateful = `true`,
		const std::deque< MaterialBase * > *	reinit_mats = `nullptr`
	)

reinit materials on the neighboring element face

Parameters

blk_id	The subdomain on which the neighbor element lives
tid	The thread id
swap_stateful	Whether to swap stateful material properties between `MaterialData` and `MaterialPropertyStorage`
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4451 of file FEProblemBase.C.

{
  if (hasActiveMaterialProperties(tid))
  {
    // NOTE: this will not work with h-adaptivity
    // lindsayad: why not?
 
    const Elem * neighbor = _assembly[tid][0]->neighbor();
    unsigned int neighbor_side = neighbor->which_neighbor_am_i(_assembly[tid][0]->elem());
 
    mooseAssert(neighbor, "neighbor should be non-null");
    mooseAssert(blk_id == neighbor->subdomain_id(),
                "The provided blk_id " << blk_id << " and neighbor subdomain ID "
                                       << neighbor->subdomain_id() << " do not match.");
 
    unsigned int n_points = _assembly[tid][0]->qRuleNeighbor()->n_points();
 
    auto & neighbor_material_data = _neighbor_material_props.getMaterialData(tid);
    neighbor_material_data.resize(n_points);
 
    // Only swap if requested
    if (swap_stateful)
      neighbor_material_data.swap(*neighbor, neighbor_side);
 
    if (_discrete_materials[Moose::NEIGHBOR_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
      neighbor_material_data.reset(
          _discrete_materials[Moose::NEIGHBOR_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
 
    if (reinit_mats)
      neighbor_material_data.reinit(*reinit_mats);
    else if (_materials[Moose::NEIGHBOR_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
      neighbor_material_data.reinit(
          _materials[Moose::NEIGHBOR_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid));
  }
}

Referenced by Moose::Mortar::loopOverMortarSegments(), ComputeUserObjectsThread::onInterface(), ComputeIndicatorThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), NonlinearThread::onInternalSide(), reinitMaterialsNeighborOnBoundary(), and NonlinearSystemBase::reinitNodeFace().

◆ reinitMaterialsNeighborOnBoundary()

void FEProblemBase::reinitMaterialsNeighborOnBoundary	(	const BoundaryID	boundary_id,
		const SubdomainID	blk_id,
		const THREAD_ID	tid,
		const bool	swap_stateful = `true`,
		const std::deque< MaterialBase * > *const	reinit_mats = `nullptr`
	)

reinit materials on neighbor element (usually faces) on a boundary (internal or external) This specific routine helps us not reinit when don't need to

Parameters

boundary_id	The boundary on which the face belongs
blk_id	The block id to which the element (who owns the face) belong
tid	The thread id
swap_stateful	Whether to swap stateful material properties between `MaterialData` and `MaterialPropertyStorage`
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4434 of file FEProblemBase.C.

{
  // Since objects don't declare whether they need the face or neighbor (side) material properties,
  // we use the same criteria for skipping material property computations as for face material
  // properties This could be a future optimization.
  if (hasActiveMaterialProperties(tid) && (needBoundaryMaterialOnSide(boundary_id, tid) ||
                                           needInterfaceMaterialOnSide(boundary_id, tid) ||
                                           needInternalNeighborSideMaterial(blk_id, tid)))
    reinitMaterialsNeighbor(blk_id, tid, swap_stateful, reinit_mats);
}

Referenced by NonlinearThread::onInterface().

◆ reinitMortarElem()

void SubProblem::reinitMortarElem	(	const Elem *	elem,
		const THREAD_ID	tid = `0`
	)

inherited

Reinit a mortar element to obtain a valid JxW.

Definition at line 1002 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    assembly(tid, nl_sys_num).reinitMortarElem(elem);
}

Referenced by Moose::Mortar::loopOverMortarSegments().

◆ reinitMortarUserObjects()

void FEProblemBase::reinitMortarUserObjects	(	BoundaryID	primary_boundary_id,
		BoundaryID	secondary_boundary_id,
		bool	displaced
	)

Call reinit on mortar user objects with matching primary boundary ID, secondary boundary ID, and displacement characteristics.

Definition at line 10335 of file FEProblemBase.C.

{
  const auto mortar_uos =
      getMortarUserObjects(primary_boundary_id, secondary_boundary_id, displaced);
  for (auto * const mortar_uo : mortar_uos)
  {
    mortar_uo->setNormals();
    mortar_uo->reinit();
  }
}

Referenced by Moose::Mortar::loopOverMortarSegments().

◆ reinitNeighbor()

void FEProblemBase::reinitNeighbor	(	const Elem *	elem,
		unsigned int	side,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 2541 of file FEProblemBase.C.

{
  setNeighborSubdomainID(elem, side, tid);
 
  const Elem * neighbor = elem->neighbor_ptr(side);
  unsigned int neighbor_side = neighbor->which_neighbor_am_i(elem);
 
  for (const auto i : index_range(_nl))
  {
    _assembly[tid][i]->reinitElemAndNeighbor(elem, side, neighbor, neighbor_side);
    _nl[i]->prepareNeighbor(tid);
    // Called during stateful material property evaluation outside of solve
    _assembly[tid][i]->prepareNeighbor();
  }
  _aux->prepareNeighbor(tid);
 
  for (auto & nl : _nl)
  {
    nl->reinitElemFace(elem, side, tid);
    nl->reinitNeighborFace(neighbor, neighbor_side, tid);
  }
  _aux->reinitElemFace(elem, side, tid);
  _aux->reinitNeighborFace(neighbor, neighbor_side, tid);
 
  if (_displaced_problem && _reinit_displaced_neighbor)
  {
    // There are cases like for cohesive zone modeling without significant sliding where we cannot
    // use FEInterface::inverse_map in Assembly::reinitElemAndNeighbor in the displaced problem
    // because the physical points coming from the element don't actually lie on the neighbor.
    // Moreover, what's the point of doing another physical point inversion in other cases? We only
    // care about the reference points which we can just take from the undisplaced computation
    const auto & displaced_ref_pts = _assembly[tid][0]->qRuleNeighbor()->get_points();
 
    _displaced_problem->reinitNeighbor(
        _displaced_mesh->elemPtr(elem->id()), side, tid, &displaced_ref_pts);
  }
}

Referenced by ComputeMaterialsObjectThread::onInterface(), ComputeUserObjectsThread::onInterface(), NonlinearThread::onInterface(), ComputeIndicatorThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), and reinitElemNeighborAndLowerD().

◆ reinitNeighborFaceRef()

void FEProblemBase::reinitNeighborFaceRef	(	const Elem *	neighbor_elem,
		unsigned int	neighbor_side,
		Real	tolerance,
		const std::vector< Point > *const	pts,
		const std::vector< Real > *const	weights = `nullptr`,
		const THREAD_ID	tid = `0`
	)

overridevirtual

reinitialize FE objects on a given neighbor element on a given side at a given set of reference points and then compute variable data.

Note that this method makes no assumptions about what's been called beforehand, e.g. you don't have to call some prepare method before this one. This is an all-in-one reinit

Reimplemented from SubProblem.

Definition at line 10081 of file FEProblemBase.C.

{
  SubProblem::reinitNeighborFaceRef(neighbor_elem, neighbor_side, tolerance, pts, weights, tid);
 
  if (_displaced_problem)
    _displaced_problem->reinitNeighborFaceRef(
        _displaced_mesh->elemPtr(neighbor_elem->id()), neighbor_side, tolerance, pts, weights, tid);
}

Referenced by Moose::Mortar::loopOverMortarSegments().

◆ reinitNeighborLowerDElem()

void SubProblem::reinitNeighborLowerDElem	(	const Elem *	elem,
		const THREAD_ID	tid = `0`
	)

inherited

reinitialize a neighboring lower dimensional element

Definition at line 995 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    assembly(tid, nl_sys_num).reinitNeighborLowerDElem(elem);
}

Referenced by Moose::Mortar::loopOverMortarSegments().

◆ reinitNeighborPhys() [1/2]

void FEProblemBase::reinitNeighborPhys	(	const Elem *	neighbor,
		const std::vector< Point > &	physical_points,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 2640 of file FEProblemBase.C.

{
  mooseAssert(_mesh.queryElemPtr(neighbor->id()) == neighbor,
              "Are you calling this method with a displaced mesh element?");
 
  for (const auto i : index_range(_nl))
  {
    // Reinits shape the functions at the physical points
    _assembly[tid][i]->reinitNeighborAtPhysical(neighbor, physical_points);
 
    // Sets the neighbor dof indices
    _nl[i]->prepareNeighbor(tid);
  }
  _aux->prepareNeighbor(tid);
 
  // Resizes Re and Ke
  _assembly[tid][_current_nl_sys->number()]->prepareNeighbor();
 
  // Compute the values of each variable at the points
  for (auto & nl : _nl)
    nl->reinitNeighbor(neighbor, tid);
  _aux->reinitNeighbor(neighbor, tid);
}

◆ reinitNeighborPhys() [2/2]

void FEProblemBase::reinitNeighborPhys	(	const Elem *	neighbor,
		unsigned int	neighbor_side,
		const std::vector< Point > &	physical_points,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 2612 of file FEProblemBase.C.

{
  mooseAssert(_mesh.queryElemPtr(neighbor->id()) == neighbor,
              "Are you calling this method with a displaced mesh element?");
 
  for (const auto i : index_range(_nl))
  {
    // Reinits shape the functions at the physical points
    _assembly[tid][i]->reinitNeighborAtPhysical(neighbor, neighbor_side, physical_points);
 
    // Sets the neighbor dof indices
    _nl[i]->prepareNeighbor(tid);
  }
  _aux->prepareNeighbor(tid);
 
  // Resizes Re and Ke
  _assembly[tid][_current_nl_sys->number()]->prepareNeighbor();
 
  // Compute the values of each variable at the points
  for (auto & nl : _nl)
    nl->reinitNeighborFace(neighbor, neighbor_side, tid);
  _aux->reinitNeighborFace(neighbor, neighbor_side, tid);
}

Referenced by NonlinearSystemBase::reinitNodeFace().

◆ reinitNode()

void FEProblemBase::reinitNode	(	const Node *	node,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 2488 of file FEProblemBase.C.

{
  if (_displaced_problem && _reinit_displaced_elem)
    _displaced_problem->reinitNode(&_displaced_mesh->nodeRef(node->id()), tid);
 
  for (const auto i : index_range(_nl))
  {
    _assembly[tid][i]->reinit(node);
    _nl[i]->reinitNode(node, tid);
  }
  _aux->reinitNode(node, tid);
}

Referenced by NodalPatchRecovery::compute(), NonlinearSystemBase::computeResidualInternal(), ComputeNodalDampingThread::onNode(), ComputeNodalKernelJacobiansThread::onNode(), ComputeNodalKernelsThread::onNode(), and ComputeNodalUserObjectsThread::onNode().

◆ reinitNodeFace()

void FEProblemBase::reinitNodeFace	(	const Node *	node,
		BoundaryID	bnd_id,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 2502 of file FEProblemBase.C.

{
  if (_displaced_problem && _reinit_displaced_face)
    _displaced_problem->reinitNodeFace(&_displaced_mesh->nodeRef(node->id()), bnd_id, tid);
 
  for (const auto i : index_range(_nl))
  {
    _assembly[tid][i]->reinit(node);
    _nl[i]->reinitNodeFace(node, bnd_id, tid);
  }
  _aux->reinitNodeFace(node, bnd_id, tid);
}

◆ reinitNodes()

void SubProblem::reinitNodes	(	const std::vector< dof_id_type > &	nodes,
		const THREAD_ID	tid
	)

inherited

Definition at line 979 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    systemBaseNonlinear(nl_sys_num).reinitNodes(nodes, tid);
  systemBaseAuxiliary().reinitNodes(nodes, tid);
}

Referenced by AuxNodalScalarKernel::compute(), NodalScalarKernel::reinit(), and NodalConstraint::reinitConstraintNodes().

◆ reinitNodesNeighbor()

void SubProblem::reinitNodesNeighbor	(	const std::vector< dof_id_type > &	nodes,
		const THREAD_ID	tid
	)

inherited

Definition at line 987 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    systemBaseNonlinear(nl_sys_num).reinitNodesNeighbor(nodes, tid);
  systemBaseAuxiliary().reinitNodesNeighbor(nodes, tid);
}

Referenced by NodalConstraint::reinitConstraintNodes().

◆ reinitOffDiagScalars()

void FEProblemBase::reinitOffDiagScalars ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 2533 of file FEProblemBase.C.

{
  _assembly[tid][_current_nl_sys->number()]->prepareOffDiagScalar();
  if (_displaced_problem)
    _displaced_problem->reinitOffDiagScalars(tid);
}

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians(), NonlinearSystemBase::constraintJacobians(), and NonlinearThread::onElement().

◆ reinitScalars()

void FEProblemBase::reinitScalars	(	const THREAD_ID	tid,
		bool	reinit_for_derivative_reordering = `false`
	)

overridevirtual

fills the VariableValue arrays for scalar variables from the solution vector

Parameters

tid	The thread id
reinit_for_derivative_reordering	A flag indicating whether we are reinitializing for the purpose of re-ordering derivative information for ADNodalBCs

Implements SubProblem.

Definition at line 2516 of file FEProblemBase.C.

{
  TIME_SECTION("reinitScalars", 3, "Reinitializing Scalar Variables");
 
  if (_displaced_problem && _reinit_displaced_elem)
    _displaced_problem->reinitScalars(tid, reinit_for_derivative_reordering);
 
  for (auto & nl : _nl)
    nl->reinitScalars(tid, reinit_for_derivative_reordering);
  _aux->reinitScalars(tid, reinit_for_derivative_reordering);
 
  // This is called outside of residual/Jacobian call-backs
  for (auto & assembly : _assembly[tid])
    assembly->prepareScalar();
}

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), computeJacobianTags(), NonlinearSystemBase::computeNodalBCsJacobian(), computeResidualAndJacobian(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), computeResidualTags(), NonlinearSystemBase::computeScalarKernelsJacobians(), and AuxiliarySystem::computeScalarVars().

◆ removeAlgebraicGhostingFunctor()

void SubProblem::removeAlgebraicGhostingFunctor ( libMesh::GhostingFunctor & algebraic_gf )

inherited

Remove an algebraic ghosting functor from this problem's DofMaps.

Definition at line 1075 of file SubProblem.C.

{
  EquationSystems & eq = es();
  const auto n_sys = eq.n_systems();
  DofMap & nl_dof_map = eq.get_system(0).get_dof_map();
 
  const bool found_in_root_sys =
      std::find(nl_dof_map.algebraic_ghosting_functors_begin(),
                nl_dof_map.algebraic_ghosting_functors_end(),
                &algebraic_gf) != nl_dof_map.algebraic_ghosting_functors_end();
 
#ifndef NDEBUG
  const bool found_in_our_map =
      _root_alg_gf_to_sys_clones.find(&algebraic_gf) != _root_alg_gf_to_sys_clones.end();
  mooseAssert(found_in_root_sys == found_in_our_map,
              "If the ghosting functor exists in the root DofMap, then we need to have a key for "
              "it in our gf to clones map");
#endif
 
  if (found_in_root_sys) // libMesh yells if we try to remove
                         // something that's not there
    nl_dof_map.remove_algebraic_ghosting_functor(algebraic_gf);
 
  auto it = _root_alg_gf_to_sys_clones.find(&algebraic_gf);
  if (it == _root_alg_gf_to_sys_clones.end())
    return;
 
  auto & clones_vec = it->second;
  mooseAssert((n_sys - 1) == clones_vec.size(),
              "The size of the gf clones vector doesn't match the number of systems minus one");
  if (clones_vec.empty())
  {
    mooseAssert(n_sys == 1, "The clones vector should only be empty if there is only one system");
    return;
  }
 
  for (const auto i : make_range(n_sys))
    eq.get_system(i + 1).get_dof_map().remove_algebraic_ghosting_functor(*clones_vec[i]);
 
  _root_alg_gf_to_sys_clones.erase(it->first);
}

◆ removeCouplingGhostingFunctor()

void SubProblem::removeCouplingGhostingFunctor ( libMesh::GhostingFunctor & coupling_gf )

inherited

Remove a coupling ghosting functor from this problem's DofMaps.

Definition at line 1118 of file SubProblem.C.

{
  EquationSystems & eq = es();
  const auto num_nl_sys = numNonlinearSystems();
  if (!num_nl_sys)
    return;
 
  DofMap & nl_dof_map = eq.get_system(0).get_dof_map();
  const bool found_in_root_sys = std::find(nl_dof_map.coupling_functors_begin(),
                                           nl_dof_map.coupling_functors_end(),
                                           &coupling_gf) != nl_dof_map.coupling_functors_end();
 
#ifndef NDEBUG
  const bool found_in_our_map =
      _root_coupling_gf_to_sys_clones.find(&coupling_gf) != _root_coupling_gf_to_sys_clones.end();
  mooseAssert(found_in_root_sys == found_in_our_map,
              "If the ghosting functor exists in the root DofMap, then we need to have a key for "
              "it in our gf to clones map");
#endif
 
  if (found_in_root_sys) // libMesh yells if we try to remove
                         // something that's not there
    nl_dof_map.remove_coupling_functor(coupling_gf);
 
  auto it = _root_coupling_gf_to_sys_clones.find(&coupling_gf);
  if (it == _root_coupling_gf_to_sys_clones.end())
    return;
 
  auto & clones_vec = it->second;
  mooseAssert((num_nl_sys - 1) == clones_vec.size(),
              "The size of the gf clones vector doesn't match the number of systems minus one");
  if (clones_vec.empty())
  {
    mooseAssert(num_nl_sys == 1,
                "The clones vector should only be empty if there is only one nonlinear system");
    return;
  }
 
  for (const auto i : make_range(num_nl_sys))
    eq.get_system(i + 1).get_dof_map().remove_coupling_functor(*clones_vec[i]);
 
  _root_coupling_gf_to_sys_clones.erase(it->first);
}

◆ reportMooseObjectDependency()

void FEProblemBase::reportMooseObjectDependency	(	MooseObject *	a,
		MooseObject *	b
	)

Register a MOOSE object dependency so we can either order operations properly or report when we cannot.

a -> b (a depends on b)

Definition at line 5776 of file FEProblemBase.C.

{
  //<< "Object " << a->name() << " -> " << b->name() << std::endl;
}

◆ resetFailNextNonlinearConvergenceCheck()

void FEProblemBase::resetFailNextNonlinearConvergenceCheck ( )

inline

Tell the problem that the nonlinear convergence check(s) may proceed as normal.

Definition at line 2979 of file FEProblemBase.h.

2979{ resetFailNextSystemConvergenceCheck(); }

FEProblemBase::resetFailNextSystemConvergenceCheck

void resetFailNextSystemConvergenceCheck()

Tell the problem that the system convergence check(s) may proceed as normal.

Definition FEProblemBase.h:2981

Referenced by Moose::PetscSupport::petscNonlinearConverged().

◆ resetFailNextSystemConvergenceCheck()

void FEProblemBase::resetFailNextSystemConvergenceCheck ( )

inline

Tell the problem that the system convergence check(s) may proceed as normal.

Definition at line 2981 of file FEProblemBase.h.

2981{ _fail_next_system_convergence_check = false; }

Referenced by Moose::PetscSupport::petscLinearConverged(), and resetFailNextNonlinearConvergenceCheck().

◆ resetState()

void FEProblemBase::resetState ( )

privatevirtual

Reset state of this object in preparation for the next evaluation.

Definition at line 7378 of file FEProblemBase.C.

{
  // Our default state is to allow computing derivatives
  ADReal::do_derivatives = true;
  _current_execute_on_flag = EXEC_NONE;
 
  // Clear the VectorTags and MatrixTags
  clearCurrentResidualVectorTags();
  clearCurrentJacobianMatrixTags();
 
  _safe_access_tagged_vectors = true;
  _safe_access_tagged_matrices = true;
 
  setCurrentlyComputingResidual(false);
  setCurrentlyComputingJacobian(false);
  setCurrentlyComputingResidualAndJacobian(false);
  if (_displaced_problem)
  {
    _displaced_problem->setCurrentlyComputingResidual(false);
    _displaced_problem->setCurrentlyComputingJacobian(false);
    _displaced_problem->setCurrentlyComputingResidualAndJacobian(false);
  }
}

Referenced by computeJacobianTags(), computeResidualAndJacobian(), and computeResidualTags().

◆ residualSetup()

void FEProblemBase::residualSetup ( )

overridevirtual

Reimplemented from SubProblem.

Definition at line 10235 of file FEProblemBase.C.

{
  SubProblem::residualSetup();
  // We need to setup all the nonlinear systems other than our current one which actually called
  // this method (so we have to make sure we don't go in a circle)
  for (const auto i : make_range(numNonlinearSystems()))
    if (i != currentNlSysNum())
      _nl[i]->residualSetup();
  // We don't setup the aux sys because that's been done elsewhere
  if (_displaced_problem)
    _displaced_problem->residualSetup();
}

Referenced by residualSetup(), and NonlinearSystemBase::residualSetup().

◆ resizeMaterialData()

void FEProblemBase::resizeMaterialData	(	Moose::MaterialDataType	data_type,
		unsigned int	nqp,
		const THREAD_ID	tid
	)

Resize material data.

Parameters

data_type	The type of material data to resize
nqp	The number of quadrature points to resize for
tid	The thread ID

Definition at line 10152 of file FEProblemBase.C.

{
  getMaterialData(data_type, tid).resize(nqp);
}

◆ restartableName()

std::string Restartable::restartableName ( const std::string & data_name ) const

protectedinherited

Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

This should only be used in this interface and in testing.

Definition at line 78 of file Restartable.C.

{
  return _restartable_system_name + "/" + _restartable_name + "/" + data_name;
}

Referenced by Restartable::declareRecoverableData(), and Restartable::declareRestartableDataHelper().

◆ restoreGeometricSearchState()

void FEProblemBase::restoreGeometricSearchState ( )

Restore geometric search state captured by the most recent backupGeometricSearchState().

Called from TimeStepper::rejectStep(), which must call this before restoreSolutions() so that the geometric search re-projects from the restored, accepted-state seeds rather than from the discarded attempt's converged state.

Definition at line 7546 of file FEProblemBase.C.

{
  _geometric_search_data.restore();
 
  if (_displaced_problem)
    _displaced_problem->geomSearchData().restore();
}

Referenced by TimeStepper::rejectStep().

◆ restoreMultiApps()

void FEProblemBase::restoreMultiApps	(	ExecFlagType	type,
		bool	force = `false`
	)

Restore the MultiApps associated with the ExecFlagType.

Parameters

force Force restoration because something went wrong with the solve

Definition at line 6424 of file FEProblemBase.C.

{
  const auto & multi_apps = _multi_apps[type].getActiveObjects();
 
  if (multi_apps.size())
  {
    if (_verbose_multiapps)
    {
      if (force)
        _console << COLOR_CYAN << "\nRestoring Multiapps on " << type.name()
                 << " because of solve failure!" << COLOR_DEFAULT << std::endl;
      else
        _console << COLOR_CYAN << "\nRestoring MultiApps on " << type.name() << COLOR_DEFAULT
                 << std::endl;
    }
 
    for (const auto & multi_app : multi_apps)
      multi_app->restore(force);
 
    MooseUtils::parallelBarrierNotify(_communicator, _parallel_barrier_messaging);
 
    if (_verbose_multiapps)
      _console << COLOR_CYAN << "Finished Restoring MultiApps on " << type.name() << "\n"
               << COLOR_DEFAULT << std::endl;
  }
}

Referenced by TransientBase::incrementStepOrReject(), and FixedPointSolve::solve().

◆ restoreOldSolutions()

void FEProblemBase::restoreOldSolutions ( )

virtual

Restore old solutions from the backup vectors and deallocate them.

Definition at line 7593 of file FEProblemBase.C.

{
  TIME_SECTION("restoreOldSolutions", 5, "Restoring Old Solutions");
 
  for (auto & sys : _solver_systems)
    sys->restoreOldSolutions();
  _aux->restoreOldSolutions();
}

Referenced by EigenExecutionerBase::inversePowerIteration().

◆ restoreOriginalNonzeroPattern()

bool FEProblemBase::restoreOriginalNonzeroPattern ( ) const

inline

Returns: Whether the original matrix nonzero pattern is restored before each Jacobian assembly

Definition at line 2432 of file FEProblemBase.h.

2432{ return _restore_original_nonzero_pattern; }

Referenced by NonlinearSystemBase::computeJacobianInternal().

◆ restoreSolutions()

void FEProblemBase::restoreSolutions ( )

virtual

Definition at line 7555 of file FEProblemBase.C.

{
  TIME_SECTION("restoreSolutions", 5, "Restoring Solutions");
 
  if (!_not_zeroed_tagged_vectors.empty())
    paramError("not_zeroed_tag_vectors",
               "There is currently no way to restore not-zeroed vectors.");
 
  for (auto & sys : _solver_systems)
  {
    if (_verbose_restore)
      _console << "Restoring solutions on system " << sys->name() << "..." << std::endl;
    sys->restoreStateHistory();
  }
 
  if (_verbose_restore)
    _console << "Restoring solutions on Auxiliary system..." << std::endl;
  _aux->restoreStateHistory();
 
  if (_verbose_restore)
    _console << "Restoring postprocessor, vector-postprocessor, and reporter data..." << std::endl;
  _reporter_data.restoreState(_verbose_restore);
 
  if (_displaced_problem)
    _displaced_problem->updateMesh();
}

Referenced by ActivateElementsUserObjectBase::initSolutions(), TimeStepper::rejectStep(), and updateMeshXFEM().

◆ restrictionBoundaryCheckName()

std::string SubProblem::restrictionBoundaryCheckName ( BoundaryID check_id )

privateinherited

Definition at line 775 of file SubProblem.C.

{
  return mesh().getMesh().get_boundary_info().sideset_name(check_id);
}

Referenced by SubProblem::checkBoundaryMatProps().

◆ restrictionSubdomainCheckName()

std::string SubProblem::restrictionSubdomainCheckName ( SubdomainID check_id )

privateinherited

Helper functions for checking MaterialProperties.

Definition at line 764 of file SubProblem.C.

{
  // TODO: Put a better a interface in MOOSE
  std::map<subdomain_id_type, std::string> & name_map = mesh().getMesh().set_subdomain_name_map();
  std::map<subdomain_id_type, std::string>::const_iterator pos = name_map.find(check_id);
  if (pos != name_map.end())
    return pos->second;
  return "";
}

Referenced by SubProblem::checkBlockMatProps().

◆ safeAccessTaggedMatrices()

virtual bool SubProblem::safeAccessTaggedMatrices ( ) const

inlinevirtualinherited

Is it safe to access the tagged matrices.

Reimplemented in DisplacedProblem.

Definition at line 742 of file SubProblem.h.

742{ return _safe_access_tagged_matrices; }

Referenced by MooseVariableScalar::reinit(), and DisplacedProblem::safeAccessTaggedMatrices().

◆ safeAccessTaggedVectors()

virtual bool SubProblem::safeAccessTaggedVectors ( ) const

inlinevirtualinherited

Is it safe to access the tagged vectors.

Reimplemented in DisplacedProblem.

Definition at line 745 of file SubProblem.h.

745{ return _safe_access_tagged_vectors; }

Referenced by MooseVariableScalar::reinit(), and DisplacedProblem::safeAccessTaggedVectors().

◆ saveOldSolutions()

void FEProblemBase::saveOldSolutions ( )

virtual

Allocate vectors and save old solutions into them.

Definition at line 7583 of file FEProblemBase.C.

{
  TIME_SECTION("saveOldSolutions", 5, "Saving Old Solutions");
 
  for (auto & sys : _solver_systems)
    sys->saveOldSolutions();
  _aux->saveOldSolutions();
}

Referenced by EigenExecutionerBase::inversePowerIteration().

◆ selectMatrixTagsFromSystem()

void SubProblem::selectMatrixTagsFromSystem	(	const SystemBase &	system,
		const std::map< TagName, TagID > &	input_matrix_tags,
		std::set< TagID > &	selected_tags
	)

staticinherited

Select the matrix tags which belong to a specific system.

Parameters

system	Reference to the system
input_matrix_tags	A map of matrix tags
selected_tags	A set which gets populated by the tag-ids that belong to the system

Definition at line 292 of file SubProblem.C.

{
  selected_tags.clear();
  for (const auto & matrix_tag_pair : input_matrix_tags)
    if (system.hasMatrix(matrix_tag_pair.second))
      selected_tags.insert(matrix_tag_pair.second);
}

Referenced by computeLinearSystemSys().

◆ selectVectorTagsFromSystem()

void SubProblem::selectVectorTagsFromSystem	(	const SystemBase &	system,
		const std::vector< VectorTag > &	input_vector_tags,
		std::set< TagID > &	selected_tags
	)

staticinherited

Select the vector tags which belong to a specific system.

Parameters

system	Reference to the system
input_vector_tags	A vector of vector tags
selected_tags	A set which gets populated by the tag-ids that belong to the system

Definition at line 281 of file SubProblem.C.

{
  selected_tags.clear();
  for (const auto & vector_tag : input_vector_tags)
    if (system.hasVector(vector_tag._id))
      selected_tags.insert(vector_tag._id);
}

Referenced by computeLinearSystemSys(), computeResidualAndJacobian(), and ComputeResidualAndJacobianThread::determineObjectWarehouses().

◆ setActiveElementalMooseVariables()

void FEProblemBase::setActiveElementalMooseVariables	(	const std::set< MooseVariableFEBase * > &	moose_vars,
		const THREAD_ID	tid
	)

overridevirtual

Set the MOOSE variables to be reinited on each element.

Parameters

moose_vars	A set of variables that need to be reinited each time reinit() is called.
tid	The thread id

Reimplemented from SubProblem.

Definition at line 6697 of file FEProblemBase.C.

{
  SubProblem::setActiveElementalMooseVariables(moose_vars, tid);
 
  if (_displaced_problem)
    _displaced_problem->setActiveElementalMooseVariables(moose_vars, tid);
}

Referenced by prepareMaterials(), ComputeDiracThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), ComputeMarkerThread::subdomainChanged(), ComputeMaterialsObjectThread::subdomainChanged(), and ComputeUserObjectsThread::subdomainChanged().

◆ setActiveFEVariableCoupleableMatrixTags()

void FEProblemBase::setActiveFEVariableCoupleableMatrixTags	(	std::set< TagID > &	mtags,
		const THREAD_ID	tid
	)

overridevirtual

Reimplemented from SubProblem.

Definition at line 6659 of file FEProblemBase.C.

{
  SubProblem::setActiveFEVariableCoupleableMatrixTags(mtags, tid);
 
  if (_displaced_problem)
    _displaced_problem->setActiveFEVariableCoupleableMatrixTags(mtags, tid);
}

◆ setActiveFEVariableCoupleableVectorTags()

void FEProblemBase::setActiveFEVariableCoupleableVectorTags	(	std::set< TagID > &	vtags,
		const THREAD_ID	tid
	)

overridevirtual

Reimplemented from SubProblem.

Definition at line 6668 of file FEProblemBase.C.

{
  SubProblem::setActiveFEVariableCoupleableVectorTags(vtags, tid);
 
  if (_displaced_problem)
    _displaced_problem->setActiveFEVariableCoupleableVectorTags(vtags, tid);
}

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute(), ComputeNodalKernelBcsThread::onNode(), ComputeNodalKernelsThread::onNode(), ComputeNodalUserObjectsThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), ComputeMaterialsObjectThread::subdomainChanged(), and ComputeUserObjectsThread::subdomainChanged().

◆ setActiveMaterialProperties()

void FEProblemBase::setActiveMaterialProperties	(	const std::unordered_set< unsigned int > &	mat_prop_ids,
		const THREAD_ID	tid
	)

Record and set the material properties required by the current computing thread.

Parameters

mat_prop_ids	The set of material properties required by the current computing thread.
tid	The thread id

Definition at line 6752 of file FEProblemBase.C.

{
  // mark active properties in every material
  for (auto & mat : _all_materials.getObjects(tid))
    mat->setActiveProperties(mat_prop_ids);
  for (auto & mat : _all_materials[Moose::FACE_MATERIAL_DATA].getObjects(tid))
    mat->setActiveProperties(mat_prop_ids);
  for (auto & mat : _all_materials[Moose::NEIGHBOR_MATERIAL_DATA].getObjects(tid))
    mat->setActiveProperties(mat_prop_ids);
 
  _has_active_material_properties[tid] = !mat_prop_ids.empty();
}

Referenced by Moose::Mortar::loopOverMortarSegments(), prepareMaterials(), NodalPatchRecovery::reinitPatch(), NonlinearSystemBase::setConstraintSecondaryValues(), and ComputeDiracThread::subdomainChanged().

◆ setActiveScalarVariableCoupleableMatrixTags()

void FEProblemBase::setActiveScalarVariableCoupleableMatrixTags	(	std::set< TagID > &	mtags,
		const THREAD_ID	tid
	)

overridevirtual

Reimplemented from SubProblem.

Definition at line 6677 of file FEProblemBase.C.

{
  SubProblem::setActiveScalarVariableCoupleableMatrixTags(mtags, tid);
 
  if (_displaced_problem)
    _displaced_problem->setActiveScalarVariableCoupleableMatrixTags(mtags, tid);
}

Referenced by AuxiliarySystem::setScalarVariableCoupleableTags().

◆ setActiveScalarVariableCoupleableVectorTags()

void FEProblemBase::setActiveScalarVariableCoupleableVectorTags	(	std::set< TagID > &	vtags,
		const THREAD_ID	tid
	)

overridevirtual

Reimplemented from SubProblem.

Definition at line 6687 of file FEProblemBase.C.

{
  SubProblem::setActiveScalarVariableCoupleableVectorTags(vtags, tid);
 
  if (_displaced_problem)
    _displaced_problem->setActiveScalarVariableCoupleableVectorTags(vtags, tid);
}

Referenced by AuxiliarySystem::setScalarVariableCoupleableTags().

◆ setAuxKernelParamsAndLog()

void FEProblemBase::setAuxKernelParamsAndLog	(	const std::string &	ak_name,
		const std::string &	name,
		InputParameters &	parameters,
		const std::string &	base_name
	)

private

Set the subproblem and system parameters for auxiliary kernels and log their addition.

Parameters

ak_name	The type of the auxiliary kernel
name	The name of the auxiliary kernel
parameters	The auxiliary kernel parameters
base_name	The base type of the auxiliary kernel, i.e. AuxKernel or KokkosAuxKernel

Definition at line 3188 of file FEProblemBase.C.

{
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->auxSys();
    parameters.set<SystemBase *>("_nl_sys") = &_displaced_problem->solverSys(0);
    if (!parameters.get<std::vector<BoundaryName>>("boundary").empty())
      _reinit_displaced_face = true;
    else
      _reinit_displaced_elem = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow AuxKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this AuxKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _aux.get();
    parameters.set<SystemBase *>("_nl_sys") = _solver_systems[0].get();
  }
 
  logAdd(base_name, name, ak_name, parameters);
}

Referenced by addAuxKernel().

◆ setAxisymmetricCoordAxis()

void FEProblemBase::setAxisymmetricCoordAxis ( const MooseEnum & rz_coord_axis )

Definition at line 922 of file FEProblemBase.C.

{
  _mesh.setAxisymmetricCoordAxis(rz_coord_axis);
}

◆ setChainControlDataOutput()

void SubProblem::setChainControlDataOutput ( bool set_output )

inlineinherited

Setter for debug chain control data output.

Definition at line 931 of file SubProblem.h.

931{ _show_chain_control_data = set_output; }

SubProblem::_show_chain_control_data

bool _show_chain_control_data

Whether to output a list of all the chain control data.

Definition SubProblem.h:1168

◆ setCheckResidualForNans()

void FEProblemBase::setCheckResidualForNans ( bool check_residual_for_nans )

inline

Setter for residual NaN/Inf checking.

Definition at line 235 of file FEProblemBase.h.

  {
    _check_residual_for_nans = check_residual_for_nans;
  }

◆ setConstJacobian()

void FEProblemBase::setConstJacobian ( bool state )

inline

Set flag that Jacobian is constant (for optimization purposes)

Parameters

state True if the Jacobian is constant, false otherwise

Definition at line 2275 of file FEProblemBase.h.

2275{ _const_jacobian = state; }

Referenced by ExplicitEuler::preSolve(), ExplicitRK2::preSolve(), and ExplicitTVDRK2::preSolve().

◆ setCoordSystem()

void FEProblemBase::setCoordSystem	(	const std::vector< SubdomainName > &	blocks,
		const MultiMooseEnum &	coord_sys
	)

Definition at line 914 of file FEProblemBase.C.

{
  TIME_SECTION("setCoordSystem", 5, "Setting Coordinate System");
  _mesh.setCoordSystem(blocks, coord_sys);
}

◆ setCoupling()

void FEProblemBase::setCoupling ( Moose::CouplingType type )

Set the coupling between variables TODO: allow user-defined coupling.

Parameters

type	Type of coupling

Definition at line 6928 of file FEProblemBase.C.

{
  if (_trust_user_coupling_matrix)
  {
    if (_coupling != Moose::COUPLING_CUSTOM)
      mooseError("Someone told us (the FEProblemBase) to trust the user coupling matrix, but we "
                 "haven't been provided a coupling matrix!");
 
    // We've been told to trust the user coupling matrix, so we're going to leave things alone
    return;
  }
 
  _coupling = type;
}

Referenced by init(), and Moose::SlepcSupport::setEigenProblemSolverParams().

◆ setCouplingMatrix() [1/2]

void FEProblemBase::setCouplingMatrix	(	libMesh::CouplingMatrix *	cm,
		const unsigned int	nl_sys_num
	)

◆ setCouplingMatrix() [2/2]

void FEProblemBase::setCouplingMatrix	(	std::unique_ptr< libMesh::CouplingMatrix >	cm,
		const unsigned int	nl_sys_num
	)

Set custom coupling matrix.

Parameters

cm	coupling matrix to be set
nl_sys_num	which nonlinear system we are setting the coupling matrix for

Referenced by MoosePreconditioner::setCouplingMatrix().

◆ setCurrentAlgebraicBndNodeRange()

void FEProblemBase::setCurrentAlgebraicBndNodeRange ( ConstBndNodeRange * range )

Definition at line 10452 of file FEProblemBase.C.

{
  if (!range)
  {
    _current_algebraic_bnd_node_range = nullptr;
    return;
  }
 
  _current_algebraic_bnd_node_range = std::make_unique<ConstBndNodeRange>(*range);
}

◆ setCurrentAlgebraicElementRange()

void FEProblemBase::setCurrentAlgebraicElementRange ( libMesh::ConstElemRange * range )

These functions allow setting custom ranges for the algebraic elements, nodes, and boundary nodes that contribute to the jacobian and residual for this local processor.

setCurrentAlgebraicElementRange() sets the element range that contributes to the system. A nullptr will reset the range to use the mesh's range.

setCurrentAlgebraicNodeRange() sets the node range that contributes to the system. A nullptr will reset the range to use the mesh's range.

setCurrentAlgebraicBndNodeRange() sets the boundary node range that contributes to the system. A nullptr will reset the range to use the mesh's range.

Parameters

range A pointer to the const range object representing the algebraic elements, nodes, or boundary nodes.

Definition at line 10430 of file FEProblemBase.C.

{
  if (!range)
  {
    _current_algebraic_elem_range = nullptr;
    return;
  }
 
  _current_algebraic_elem_range = std::make_unique<ConstElemRange>(*range);
}

◆ setCurrentAlgebraicNodeRange()

void FEProblemBase::setCurrentAlgebraicNodeRange ( libMesh::ConstNodeRange * range )

Definition at line 10441 of file FEProblemBase.C.

{
  if (!range)
  {
    _current_algebraic_node_range = nullptr;
    return;
  }
 
  _current_algebraic_node_range = std::make_unique<ConstNodeRange>(*range);
}

◆ setCurrentBoundaryID()

void FEProblemBase::setCurrentBoundaryID	(	BoundaryID	bid,
		const THREAD_ID	tid
	)

overridevirtual

sets the current boundary ID in assembly

Reimplemented from SubProblem.

Definition at line 10366 of file FEProblemBase.C.

{
  SubProblem::setCurrentBoundaryID(bid, tid);
  if (_displaced_problem)
    _displaced_problem->setCurrentBoundaryID(bid, tid);
}

◆ setCurrentExecuteOnFlag()

void FEProblemBase::setCurrentExecuteOnFlag ( const ExecFlagType & flag )

Definition at line 5170 of file FEProblemBase.C.

{
  _current_execute_on_flag = flag;
}

Referenced by execute(), MFEMProblem::execute(), initialSetup(), and outputStep().

◆ setCurrentLinearSystem()

void FEProblemBase::setCurrentLinearSystem ( unsigned int sys_num )

Set the current linear system pointer.

Parameters

sys_num The number of linear system

Definition at line 10383 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _linear_systems.size(),
              "System number greater than the number of linear systems");
  _current_linear_sys = _linear_systems[sys_num].get();
  _current_solver_sys = _current_linear_sys;
}

Referenced by computeLinearSystemSys(), LinearSystem::computeLinearSystemTags(), and solveLinearSystem().

◆ setCurrentLowerDElem()

void FEProblemBase::setCurrentLowerDElem	(	const Elem *const	lower_d_elem,
		const THREAD_ID	tid
	)

overridevirtual

Set the current lower dimensional element.

This can be null

Reimplemented from SubProblem.

Definition at line 10357 of file FEProblemBase.C.

{
  SubProblem::setCurrentLowerDElem(lower_d_elem, tid);
  if (_displaced_problem)
    _displaced_problem->setCurrentLowerDElem(
        lower_d_elem ? _displaced_mesh->elemPtr(lower_d_elem->id()) : nullptr, tid);
}

◆ setCurrentlyComputingJacobian()

void SubProblem::setCurrentlyComputingJacobian ( const bool currently_computing_jacobian )

inlineinherited

Set whether or not the problem is in the process of computing the Jacobian.

Definition at line 700 of file SubProblem.h.

  {
    _currently_computing_jacobian = currently_computing_jacobian;
  }

Referenced by computeResidualAndJacobian(), and resetState().

◆ setCurrentlyComputingResidual()

void FEProblemBase::setCurrentlyComputingResidual ( bool currently_computing_residual )

finalvirtual

Set whether or not the problem is in the process of computing the residual.

Reimplemented from SubProblem.

Definition at line 10033 of file FEProblemBase.C.

{
  if (_displaced_problem)
    _displaced_problem->setCurrentlyComputingResidual(currently_computing_residual);
  _currently_computing_residual = currently_computing_residual;
}

Referenced by computeResidualAndJacobian(), computeResidualTags(), NonlinearSystemBase::computeResidualTags(), and resetState().

◆ setCurrentlyComputingResidualAndJacobian()

void SubProblem::setCurrentlyComputingResidualAndJacobian ( bool currently_computing_residual_and_jacobian )

inlineinherited

Set whether or not the problem is in the process of computing the Jacobian.

Definition at line 1489 of file SubProblem.h.

{
  _currently_computing_residual_and_jacobian = currently_computing_residual_and_jacobian;
}

Referenced by computeResidualAndJacobian(), and resetState().

◆ setCurrentNonlinearSystem()

void FEProblemBase::setCurrentNonlinearSystem ( const unsigned int nl_sys_num )

Definition at line 10374 of file FEProblemBase.C.

{
  mooseAssert(nl_sys_num < _nl.size(),
              "System number greater than the number of nonlinear systems");
  _current_nl_sys = _nl[nl_sys_num].get();
  _current_solver_sys = _current_nl_sys;
}

Referenced by computeJacobian(), EigenProblem::computeJacobianAB(), computeJacobianBlocks(), EigenProblem::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), EigenProblem::computeJacobianTag(), EigenProblem::computeMatricesTags(), EigenProblem::computeResidualTag(), NonlinearSystemBase::computeResidualTags(), ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), solve(), and EigenProblem::solve().

◆ setCurrentResidualVectorTags()

void FEProblemBase::setCurrentResidualVectorTags ( const std::set< TagID > & vector_tags )

inline

Set the current residual vector tag data structure based on the passed in tag IDs.

Definition at line 3960 of file FEProblemBase.h.

{
  _current_residual_vector_tags = getVectorTags(vector_tags);
}

Referenced by computeResidualAndJacobian(), computeResidualTags(), and CrankNicolson::init().

◆ setCurrentSubdomainID()

void FEProblemBase::setCurrentSubdomainID	(	const Elem *	elem,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 1993 of file FEProblemBase.C.

{
  SubdomainID did = elem->subdomain_id();
  for (const auto i : index_range(_solver_systems))
  {
    _assembly[tid][i]->setCurrentSubdomainID(did);
    if (_displaced_problem &&
        (_reinit_displaced_elem || _reinit_displaced_face || _reinit_displaced_neighbor))
      _displaced_problem->assembly(tid, i).setCurrentSubdomainID(did);
  }
}

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), ElementalVariableValue::execute(), MultiAppVariableValueSamplePostprocessorTransfer::execute(), and ComputeInitialConditionThread::operator()().

◆ setErrorOnJacobianNonzeroReallocation()

void FEProblemBase::setErrorOnJacobianNonzeroReallocation ( bool state )

inline

Definition at line 2443 of file FEProblemBase.h.

  {
    _error_on_jacobian_nonzero_reallocation = state;
  }

◆ setException()

void FEProblemBase::setException ( const std::string & message )

virtual

Set an exception, which is stored at this point by toggling a member variable in this class, and which must be followed up with by a call to checkExceptionAndStopSolve().

Parameters

message The error message describing the exception, which will get printed when checkExceptionAndStopSolve() is called

Definition at line 7308 of file FEProblemBase.C.

{
  _has_exception = true;
  _exception_message = message;
}

Referenced by ComputeThreadedGeneralUserObjectsThread::caughtMooseException(), ThreadedFaceLoop< RangeType >::caughtMooseException(), ThreadedNodeLoop< RangeType, IteratorType >::caughtMooseException(), NonlinearSystemBase::computeDamping(), AuxiliarySystem::computeElementalVarsHelper(), AuxiliarySystem::computeMortarNodalVars(), handleException(), ComputeMortarFunctor::operator()(), DisplacedProblem::updateMesh(), and DisplacedProblem::updateMesh().

◆ setExecutionPrinting()

void FEProblemBase::setExecutionPrinting ( const ExecFlagEnum & print_exec )

inline

Definition at line 2987 of file FEProblemBase.h.

2987{ _print_execution_on = print_exec; }

◆ setFailNextNonlinearConvergenceCheck()

void FEProblemBase::setFailNextNonlinearConvergenceCheck ( )

inline

Skip further residual evaluations and fail the next nonlinear convergence check(s)

Definition at line 2974 of file FEProblemBase.h.

2974{ setFailNextSystemConvergenceCheck(); }

FEProblemBase::setFailNextSystemConvergenceCheck

void setFailNextSystemConvergenceCheck()

Tell the problem that the system(s) cannot be considered converged next time convergence is checked.

Definition FEProblemBase.h:2976

Referenced by Terminator::execute().

◆ setFailNextSystemConvergenceCheck()

void FEProblemBase::setFailNextSystemConvergenceCheck ( )

inline

Tell the problem that the system(s) cannot be considered converged next time convergence is checked.

Definition at line 2976 of file FEProblemBase.h.

2976{ _fail_next_system_convergence_check = true; }

Referenced by setFailNextNonlinearConvergenceCheck().

◆ setFunctorOutput()

void SubProblem::setFunctorOutput ( bool set_output )

inlineinherited

Setter for debug functor output.

Definition at line 929 of file SubProblem.h.

929{ _show_functors = set_output; }

SubProblem::_show_functors

bool _show_functors

Whether to output a list of the functors used and requested (currently only at initialSetup)

Definition SubProblem.h:1165

◆ setIgnoreZerosInJacobian()

void FEProblemBase::setIgnoreZerosInJacobian ( bool state )

inline

Set whether the zeros in the Jacobian should be dropped from the sparsity pattern.

Definition at line 2466 of file FEProblemBase.h.

2466{ _ignore_zeros_in_jacobian = state; }

◆ setInputParametersFEProblem()

virtual void FEProblemBase::setInputParametersFEProblem ( InputParameters & parameters )

inlinevirtual

Reimplemented in FEProblem.

Definition at line 1046 of file FEProblemBase.h.

  {
    parameters.set<FEProblemBase *>("_fe_problem_base") = this;
  }

Referenced by FEProblem::setInputParametersFEProblem().

◆ setKernelCoverageCheck() [1/2]

void FEProblemBase::setKernelCoverageCheck ( bool flag )

inline

Set flag to indicate whether kernel coverage checks should be performed.

This check makes sure that at least one kernel is active on all subdomains in the domain (default: true).

Definition at line 2287 of file FEProblemBase.h.

  {
    _kernel_coverage_check = flag ? CoverageCheckMode::TRUE : CoverageCheckMode::FALSE;
  }

◆ setKernelCoverageCheck() [2/2]

void FEProblemBase::setKernelCoverageCheck ( CoverageCheckMode mode )

inline

Set flag to indicate whether kernel coverage checks should be performed.

This check makes sure that at least one kernel is active on all subdomains in the domain (default: true).

Definition at line 2281 of file FEProblemBase.h.

2281{ _kernel_coverage_check = mode; }

◆ setLinearConvergenceNames()

void FEProblemBase::setLinearConvergenceNames ( const std::vector< ConvergenceName > & convergence_names )

Sets the linear convergence object name(s) if there is one.

Definition at line 10201 of file FEProblemBase.C.

{
  if (convergence_names.size() != numLinearSystems())
    paramError("linear_convergence", "There must be one convergence object per linear system");
  _linear_convergence_names = convergence_names;
}

Referenced by FEProblemSolve::FEProblemSolve().

◆ setMaterialCoverageCheck() [1/2]

void FEProblemBase::setMaterialCoverageCheck ( bool flag )

inline

Set flag to indicate whether material coverage checks should be performed.

This check makes sure that at least one material is active on all subdomains in the domain if any material is supplied. If no materials are supplied anywhere, a simulation is still considered OK as long as no properties are being requested anywhere.

Definition at line 2306 of file FEProblemBase.h.

  {
    _material_coverage_check = flag ? CoverageCheckMode::TRUE : CoverageCheckMode::FALSE;
  }

◆ setMaterialCoverageCheck() [2/2]

void FEProblemBase::setMaterialCoverageCheck ( CoverageCheckMode mode )

inline

Set flag to indicate whether material coverage checks should be performed.

This check makes sure that at least one material is active on all subdomains in the domain if any material is supplied. If no materials are supplied anywhere, a simulation is still considered OK as long as no properties are being requested anywhere.

Definition at line 2298 of file FEProblemBase.h.

2298{ _material_coverage_check = mode; }

◆ setMultiAppFixedPointConvergenceName()

void FEProblemBase::setMultiAppFixedPointConvergenceName ( const ConvergenceName & convergence_name )

Sets the MultiApp fixed point convergence object name if there is one.

Definition at line 10173 of file FEProblemBase.C.

{
  _multiapp_fixed_point_convergence_name = convergence_name;
}

Referenced by FixedPointSolve::FixedPointSolve().

◆ setNeedToAddDefaultMultiAppFixedPointConvergence()

void FEProblemBase::setNeedToAddDefaultMultiAppFixedPointConvergence ( )

inline

Sets _need_to_add_default_multiapp_fixed_point_convergence to true.

Definition at line 783 of file FEProblemBase.h.

  {
    _need_to_add_default_multiapp_fixed_point_convergence = true;
  }

Referenced by FixedPointSolve::FixedPointSolve().

◆ setNeedToAddDefaultNonlinearConvergence()

void FEProblemBase::setNeedToAddDefaultNonlinearConvergence ( )

inline

Sets _need_to_add_default_nonlinear_convergence to true.

Definition at line 778 of file FEProblemBase.h.

  {
    _need_to_add_default_nonlinear_convergence = true;
  }

Referenced by FEProblemSolve::FEProblemSolve().

◆ setNeedToAddDefaultSteadyStateConvergence()

void FEProblemBase::setNeedToAddDefaultSteadyStateConvergence ( )

inline

Sets _need_to_add_default_steady_state_convergence to true.

Definition at line 788 of file FEProblemBase.h.

  {
    _need_to_add_default_steady_state_convergence = true;
  }

Referenced by TransientBase::TransientBase().

◆ setNeighborSubdomainID() [1/2]

void FEProblemBase::setNeighborSubdomainID	(	const Elem *	elem,
		const THREAD_ID	tid
	)

virtual

Definition at line 2019 of file FEProblemBase.C.

{
  SubdomainID did = elem->subdomain_id();
  for (const auto i : index_range(_nl))
  {
    _assembly[tid][i]->setCurrentNeighborSubdomainID(did);
    if (_displaced_problem &&
        (_reinit_displaced_elem || _reinit_displaced_face || _reinit_displaced_neighbor))
      _displaced_problem->assembly(tid, i).setCurrentNeighborSubdomainID(did);
  }
}

◆ setNeighborSubdomainID() [2/2]

void FEProblemBase::setNeighborSubdomainID	(	const Elem *	elem,
		unsigned int	side,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 2006 of file FEProblemBase.C.

{
  SubdomainID did = elem->neighbor_ptr(side)->subdomain_id();
  for (const auto i : index_range(_nl))
  {
    _assembly[tid][i]->setCurrentNeighborSubdomainID(did);
    if (_displaced_problem &&
        (_reinit_displaced_elem || _reinit_displaced_face || _reinit_displaced_neighbor))
      _displaced_problem->assembly(tid, i).setCurrentNeighborSubdomainID(did);
  }
}

Referenced by NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), reinitNeighbor(), and NonlinearSystemBase::reinitNodeFace().

◆ setNonlinearConvergenceNames()

void FEProblemBase::setNonlinearConvergenceNames ( const std::vector< ConvergenceName > & convergence_names )

Sets the nonlinear convergence object name(s) if there is one.

Definition at line 10160 of file FEProblemBase.C.

{
  if (convergence_names.size() != numNonlinearSystems())
    paramError("nonlinear_convergence",
               "There must be one convergence object per nonlinear system");
 
  _nonlinear_convergence_names = convergence_names;
 
  for (const auto i : make_range(numNonlinearSystems()))
    _nl[i]->setConvergenceName(convergence_names[i]);
}

Referenced by FEProblemSolve::FEProblemSolve().

◆ setNonlocalCouplingMatrix()

void FEProblemBase::setNonlocalCouplingMatrix ( )

Set custom coupling matrix for variables requiring nonlocal contribution.

Definition at line 6969 of file FEProblemBase.C.

{
  TIME_SECTION("setNonlocalCouplingMatrix", 5, "Setting Nonlocal Coupling Matrix");
 
  if (_nl.size() > 1)
    mooseError("Nonlocal kernels are weirdly stored on the FEProblem so we don't currently support "
               "multiple nonlinear systems with nonlocal kernels.");
 
  for (const auto nl_sys_num : index_range(_nl))
  {
    auto & nl = _nl[nl_sys_num];
    auto & nonlocal_cm = _nonlocal_cm[nl_sys_num];
    unsigned int n_vars = nl->nVariables();
    nonlocal_cm.resize(n_vars);
    const auto & vars = nl->getVariables(0);
    const auto & nonlocal_kernel = _nonlocal_kernels.getObjects();
    const auto & nonlocal_integrated_bc = _nonlocal_integrated_bcs.getObjects();
    for (const auto & ivar : vars)
    {
      for (const auto & kernel : nonlocal_kernel)
      {
        for (unsigned int i = ivar->number(); i < ivar->number() + ivar->count(); ++i)
          if (i == kernel->variable().number())
            for (const auto & jvar : vars)
            {
              const auto it = _var_dof_map.find(jvar->name());
              if (it != _var_dof_map.end())
              {
                unsigned int j = jvar->number();
                nonlocal_cm(i, j) = 1;
              }
            }
      }
      for (const auto & integrated_bc : nonlocal_integrated_bc)
      {
        for (unsigned int i = ivar->number(); i < ivar->number() + ivar->count(); ++i)
          if (i == integrated_bc->variable().number())
            for (const auto & jvar : vars)
            {
              const auto it = _var_dof_map.find(jvar->name());
              if (it != _var_dof_map.end())
              {
                unsigned int j = jvar->number();
                nonlocal_cm(i, j) = 1;
              }
            }
      }
    }
  }
}

◆ setParallelBarrierMessaging()

void FEProblemBase::setParallelBarrierMessaging ( bool flag )

inline

Toggle parallel barrier messaging (defaults to on).

Definition at line 2314 of file FEProblemBase.h.

2314{ _parallel_barrier_messaging = flag; }

◆ setPostprocessorValueByName()

void FEProblemBase::setPostprocessorValueByName	(	const PostprocessorName &	name,
		const PostprocessorValue &	value,
		std::size_t	t_index = `0`
	)

Set the value of a PostprocessorValue.

Parameters

name	The name of the post-processor
t_index	Flag for getting current (0), old (1), or older (2) values

Returns: The reference to the value at the given time index

Note: This method is only for setting values that already exist, the Postprocessor and PostprocessorInterface objects should be used rather than this method for creating and getting values within objects.

WARNING! This method should be used with caution. It exists to allow Transfers and other similar objects to modify Postprocessor values. It is not intended for general use.

Definition at line 5007 of file FEProblemBase.C.

{
  _reporter_data.setReporterValue<PostprocessorValue>(
      PostprocessorReporterName(name), value, t_index);
}

Referenced by PIDTransientControl::execute(), MultiAppPostprocessorTransfer::execute(), MFEMProblem::executeMFEMObjects(), PIDTransientControl::initialSetup(), joinAndFinalize(), PIDTransientControl::timestepSetup(), PicardSolve::transformPostprocessors(), SecantSolve::transformPostprocessors(), and SteffensenSolve::transformPostprocessors().

◆ setPreserveMatrixSparsityPattern()

void FEProblemBase::setPreserveMatrixSparsityPattern ( bool preserve )

Set whether the sparsity pattern of the matrices being formed during the solve (usually the Jacobian) should be preserved.

This global setting can be retrieved by kernels, notably those using AD, to decide whether to take additional care to preserve the sparsity pattern

Definition at line 4132 of file FEProblemBase.C.

{
  if (_ignore_zeros_in_jacobian && preserve)
    paramWarning(
        "ignore_zeros_in_jacobian",
        "We likely cannot preserve the sparsity pattern if ignoring zeros in the Jacobian, which "
        "leads to removing those entries from the Jacobian sparsity pattern");
  _preserve_matrix_sparsity_pattern = preserve;
}

◆ setResidual() [1/2]

virtual void SubProblem::setResidual	(	libMesh::NumericVector< libMesh::Number > &	residual,
		const THREAD_ID	tid
	)

pure virtualinherited

◆ setResidual() [2/2]

void FEProblemBase::setResidual	(	NumericVector< libMesh::Number > &	residual,
		const THREAD_ID	tid
	)

overridevirtual

Definition at line 2152 of file FEProblemBase.C.

{
  _assembly[tid][_current_nl_sys->number()]->setResidual(
      residual,
      Assembly::GlobalDataKey{},
      getVectorTag(_nl[_current_nl_sys->number()]->residualVectorTag()));
  if (_displaced_problem)
    _displaced_problem->setResidual(residual, tid);
}

Referenced by NonlinearSystemBase::constraintResiduals().

◆ setResidualNeighbor() [1/2]

virtual void SubProblem::setResidualNeighbor	(	libMesh::NumericVector< libMesh::Number > &	residual,
		const THREAD_ID	tid
	)

pure virtualinherited

◆ setResidualNeighbor() [2/2]

void FEProblemBase::setResidualNeighbor	(	NumericVector< libMesh::Number > &	residual,
		const THREAD_ID	tid
	)

overridevirtual

Definition at line 2163 of file FEProblemBase.C.

{
  _assembly[tid][_current_nl_sys->number()]->setResidualNeighbor(
      residual, Assembly::GlobalDataKey{}, getVectorTag(_current_nl_sys->residualVectorTag()));
  if (_displaced_problem)
    _displaced_problem->setResidualNeighbor(residual, tid);
}

◆ setResidualObjectParamsAndLog()

void FEProblemBase::setResidualObjectParamsAndLog	(	const std::string &	ro_name,
		const std::string &	name,
		InputParameters &	parameters,
		const unsigned int	nl_sys_num,
		const std::string &	base_name,
		bool &	reinit_displaced
	)

private

Set the subproblem and system parameters for residual objects and log their addition.

Parameters

ro_name	The type of the residual object
name	The name of the residual object
parameters	The residual object parameters
nl_sys_num	The nonlinear system that the residual object belongs to
base_name	The base type of the residual object, e.g. Kernel, BoundaryCondition, etc.
reinit_displaced	A data member indicating whether a geometric concept should be reinit'd for the displaced problem. Examples of valid data members to pass in are `_reinit_displaced_elem` and `_reinit_displaced_face`

Definition at line 3155 of file FEProblemBase.C.

{
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
    reinit_displaced = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow Kernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this Kernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }
 
  logAdd(base_name, name, ro_name, parameters);
}

Referenced by addBoundaryCondition(), addHDGKernel(), and addKernel().

◆ setRestartFile()

void FEProblemBase::setRestartFile ( const std::string & file_name )

Communicate to the Resurector the name of the restart filer.

Parameters

file_name The file name for restarting from

Definition at line 9629 of file FEProblemBase.C.

{
  if (_app.isRecovering())
  {
    mooseInfo("Restart file ", file_name, " is NOT being used since we are performing recovery.");
  }
  else
  {
    _app.setRestart(true);
    _app.setRestartRecoverFileBase(file_name);
    mooseInfo("Using ", file_name, " for restart.");
  }
}

Referenced by Executioner::Executioner(), Executioner::Executioner(), and FEProblemBase().

◆ setSNESMFReuseBase()

void FEProblemBase::setSNESMFReuseBase	(	bool	reuse,
		bool	set_by_user
	)

inline

If or not to reuse the base vector for matrix-free calculation.

Definition at line 2667 of file FEProblemBase.h.

  {
    _snesmf_reuse_base = reuse, _snesmf_reuse_base_set_by_user = set_by_user;
  }

Referenced by FEProblemSolve::FEProblemSolve().

◆ setSteadyStateConvergenceName()

void FEProblemBase::setSteadyStateConvergenceName ( const ConvergenceName & convergence_name )

Sets the steady-state detection convergence object name if there is one.

Definition at line 10179 of file FEProblemBase.C.

{
  _steady_state_convergence_name = convergence_name;
}

Referenced by TransientBase::TransientBase().

◆ setUDotDotOldRequested()

virtual void FEProblemBase::setUDotDotOldRequested ( const bool u_dotdot_old_requested )

inlinevirtual

Set boolean flag to true to store old solution second time derivative.

Definition at line 2715 of file FEProblemBase.h.

  {
    _u_dotdot_old_requested = u_dotdot_old_requested;
  }

Referenced by CentralDifference::CentralDifference(), and NewmarkBeta::NewmarkBeta().

◆ setUDotDotRequested()

virtual void FEProblemBase::setUDotDotRequested ( const bool u_dotdot_requested )

inlinevirtual

Set boolean flag to true to store solution second time derivative.

Definition at line 2703 of file FEProblemBase.h.

  {
    _u_dotdot_requested = u_dotdot_requested;
  }

Referenced by CentralDifference::CentralDifference(), and NewmarkBeta::NewmarkBeta().

◆ setUDotOldRequested()

virtual void FEProblemBase::setUDotOldRequested ( const bool u_dot_old_requested )

inlinevirtual

Set boolean flag to true to store old solution time derivative.

Definition at line 2709 of file FEProblemBase.h.

  {
    _u_dot_old_requested = u_dot_old_requested;
  }

Referenced by CentralDifference::CentralDifference(), and NewmarkBeta::NewmarkBeta().

◆ setUDotRequested()

virtual void FEProblemBase::setUDotRequested ( const bool u_dot_requested )

inlinevirtual

Set boolean flag to true to store solution time derivative.

Definition at line 2700 of file FEProblemBase.h.

2700{ _u_dot_requested = u_dot_requested; }

Referenced by TimeIntegrator::TimeIntegrator().

◆ setupDampers()

void FEProblemBase::setupDampers ( )

Definition at line 5833 of file FEProblemBase.C.

{
  for (auto & nl : _nl)
    nl->setupDampers();
}

◆ setVariableAllDoFMap()

void FEProblemBase::setVariableAllDoFMap ( const std::vector< const MooseVariableFEBase * > & moose_vars )

Definition at line 1901 of file FEProblemBase.C.

{
  for (unsigned int i = 0; i < moose_vars.size(); ++i)
  {
    VariableName var_name = moose_vars[i]->name();
    auto & sys = _solver_systems[moose_vars[i]->sys().number()];
    sys->setVariableGlobalDoFs(var_name);
    _var_dof_map[var_name] = sys->getVariableGlobalDoFs();
  }
}

Referenced by meshChanged().

◆ setVectorPostprocessorValueByName()

void FEProblemBase::setVectorPostprocessorValueByName	(	const std::string &	object_name,
		const std::string &	vector_name,
		const VectorPostprocessorValue &	value,
		std::size_t	t_index = `0`
	)

Set the value of a VectorPostprocessor vector.

Parameters

object_name	The name of the VPP object
vector_name	The name of the declared vector
value	The data to apply to the vector
t_index	Flag for getting current (0), old (1), or older (2) values

Definition at line 5033 of file FEProblemBase.C.

{
  _reporter_data.setReporterValue<VectorPostprocessorValue>(
      VectorPostprocessorReporterName(object_name, vector_name), value, t_index);
}

◆ setVerboseProblem()

void FEProblemBase::setVerboseProblem ( bool verbose )

Make the problem be verbose.

Definition at line 10349 of file FEProblemBase.C.

{
  _verbose_setup = verbose ? "true" : "false";
  _verbose_multiapps = verbose;
  _verbose_restore = verbose;
}

Referenced by PhysicsBase::initializePhysics().

◆ shouldPrintExecution()

bool FEProblemBase::shouldPrintExecution ( const THREAD_ID tid ) const

Check whether the problem should output execution orders at this time.

Definition at line 10291 of file FEProblemBase.C.

{
  // For now, only support printing from thread 0
  if (tid != 0)
    return false;
 
  if (_print_execution_on.isValueSet(_current_execute_on_flag) ||
      _print_execution_on.isValueSet(EXEC_ALWAYS))
    return true;
  else
    return false;
}

◆ shouldSolve()

bool FEProblemBase::shouldSolve ( ) const

inline

Definition at line 2751 of file FEProblemBase.h.

2751{ return _solve; }

Referenced by FEProblemSolve::solve(), MFEMProblemSolve::solve(), ExternalProblem::solve(), and TransientBase::TransientBase().

◆ shouldUpdateSolution()

bool FEProblemBase::shouldUpdateSolution ( )

virtual

Check to see whether the problem should update the solution.

Returns: true if the problem should update the solution, false otherwise

Definition at line 8704 of file FEProblemBase.C.

{
  return false;
}

Referenced by computePostCheck(), and NonlinearSystem::solve().

◆ showFunctorRequestors()

void SubProblem::showFunctorRequestors ( ) const

privateinherited

Lists all functors and all the objects that requested them.

Definition at line 1264 of file SubProblem.C.

{
  for (const auto & [functor, requestors] : _functor_to_requestors)
  {
    _console << "[DBG] Requestors for wrapped functor "
             << std::regex_replace(functor, std::regex("wraps_"), "") << std::endl;
    _console << "[DBG] " << MooseUtils::join(requestors, " ") << std::endl;
  }
}

Referenced by SubProblem::initialSetup().

◆ showFunctors()

void SubProblem::showFunctors ( ) const

privateinherited

Lists all functors in the problem.

Definition at line 1252 of file SubProblem.C.

{
  _console << "[DBG] Wrapped functors found in Subproblem" << std::endl;
  std::string functor_names = "[DBG] ";
  for (const auto & functor_pair : _functors[0])
    functor_names += std::regex_replace(functor_pair.first, std::regex("wraps_"), "") + " ";
  if (functor_names.size())
    functor_names.pop_back();
  _console << functor_names << std::endl;
}

Referenced by SubProblem::initialSetup().

◆ showInvalidSolutionConsole()

bool FEProblemBase::showInvalidSolutionConsole ( ) const

inline

Whether or not to print out the invalid solutions summary table in console.

Definition at line 2483 of file FEProblemBase.h.

2483{ return _show_invalid_solution_console; }

Referenced by SolverSystem::checkInvalidSolution().

◆ sideUOInterfaceMatPropIntegrityCheck()

bool FEProblemBase::sideUOInterfaceMatPropIntegrityCheck ( ) const

inline

Returns: whether to perform an integrity check for side user objects consuming interface material properties

Definition at line 2834 of file FEProblemBase.h.

  {
    return _side_uo_interface_mat_prop_integrity_check;
  }

Referenced by SideUserObject::initialSetup().

◆ sizeZeroes()

void FEProblemBase::sizeZeroes	(	unsigned int	size,
		const THREAD_ID	tid
	)

virtual

Definition at line 2354 of file FEProblemBase.C.

{
  mooseDoOnce(mooseWarning(
      "This function is deprecated and no longer performs any function. Please do not call it."));
}

◆ skipExceptionCheck()

void FEProblemBase::skipExceptionCheck ( bool skip_exception_check )

inline

Set a flag that indicates if we want to skip exception and stop solve.

Definition at line 2680 of file FEProblemBase.h.

  {
    _skip_exception_check = skip_exception_check;
  }

Referenced by FEProblemSolve::FEProblemSolve().

◆ skipNextForwardSolutionCopyToOld()

void FEProblemBase::skipNextForwardSolutionCopyToOld ( )

Prevents the copy of the solution vector to the old solution vector in each system.

Old -> Older is still performed This is useful for MultiApps fixed point iterations

Definition at line 7486 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    sys->skipNextSolutionToOldCopy();
  _aux->skipNextSolutionToOldCopy();
}

Referenced by FullSolveMultiApp::solveStep().

◆ solve()

void FEProblemBase::solve ( const unsigned int nl_sys_num )

virtual

Reimplemented in EigenProblem, ExternalProblem, and DumpObjectsProblem.

Definition at line 7246 of file FEProblemBase.C.

{
  TIME_SECTION("solve", 1, "Solving", false);
 
  setCurrentNonlinearSystem(nl_sys_num);
 
  // This prevents stale dof indices from lingering around and possibly leading to invalid reads
  // and writes. Dof indices may be made stale through operations like mesh adaptivity
  clearAllDofIndices();
  if (_displaced_problem)
    _displaced_problem->clearAllDofIndices();
 
  // Setup the output system for printing linear/nonlinear iteration information and some solver
  // settings, including setting matrix prefixes. This must occur before petscSetOptions
  initPetscOutputAndSomeSolverSettings();
 
#if PETSC_RELEASE_LESS_THAN(3, 12, 0)
  Moose::PetscSupport::petscSetOptions(
      _petsc_options, _solver_params); // Make sure the PETSc options are setup for this app
#else
  // Now this database will be the default
  // Each app should have only one database
  if (!_app.isUltimateMaster())
    LibmeshPetscCall(PetscOptionsPush(_petsc_option_data_base));
  // We did not add PETSc options to database yet
  if (!_is_petsc_options_inserted)
  {
    // Insert options for all systems all at once
    Moose::PetscSupport::petscSetOptions(_petsc_options, _solver_params, this);
    _is_petsc_options_inserted = true;
  }
#endif
 
  // set up DM which is required if use a field split preconditioner
  // We need to setup DM every "solve()" because libMesh destroy SNES after solve()
  // Do not worry, DM setup is very cheap
  _current_nl_sys->setupDM();
 
  possiblyRebuildGeomSearchPatches();
 
  // reset flag so that residual evaluation does not get skipped
  // and the next non-linear iteration does not automatically fail with
  // "DIVERGED_NANORINF", when we throw  an exception and stop solve
  _fail_next_system_convergence_check = false;
 
  if (_solve)
  {
    _current_nl_sys->solve();
    _current_nl_sys->update();
  }
 
  // sync solutions in displaced problem
  if (_displaced_problem)
    _displaced_problem->syncSolutions();
 
#if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
  if (!_app.isUltimateMaster())
    LibmeshPetscCall(PetscOptionsPop());
#endif
}

Referenced by EigenExecutionerBase::inversePowerIteration(), EigenExecutionerBase::nonlinearSolve(), FEProblemSolve::solve(), and AB2PredictorCorrector::step().

◆ solveLinearSystem()

void FEProblemBase::solveLinearSystem	(	const unsigned int	linear_sys_num,
		const Moose::PetscSupport::PetscOptions *	po = `nullptr`
	)

virtual

Build and solve a linear system.

Parameters

linear_sys_num	The number of the linear system (1,..,num. of lin. systems)
po	The petsc options for the solve, if not supplied, the defaults are used

Reimplemented in DumpObjectsProblem.

Definition at line 7403 of file FEProblemBase.C.

{
  TIME_SECTION("solve", 1, "Solving", false);
 
  setCurrentLinearSystem(linear_sys_num);
 
  const Moose::PetscSupport::PetscOptions & options = po ? *po : _petsc_options;
  auto & solver_params = _solver_params[numNonlinearSystems() + linear_sys_num];
 
  // Set custom convergence criteria
  Moose::PetscSupport::petscSetDefaults(*this);
 
#if PETSC_RELEASE_LESS_THAN(3, 12, 0)
  LibmeshPetscCall(Moose::PetscSupport::petscSetOptions(
      options, solver_params)); // Make sure the PETSc options are setup for this app
#else
  // Now this database will be the default
  // Each app should have only one database
  if (!_app.isUltimateMaster())
    LibmeshPetscCall(PetscOptionsPush(_petsc_option_data_base));
 
  // We did not add PETSc options to database yet
  if (!_is_petsc_options_inserted)
  {
    Moose::PetscSupport::petscSetOptions(options, solver_params, this);
    _is_petsc_options_inserted = true;
  }
#endif
 
  if (_solve)
    _current_linear_sys->solve();
 
#if !PETSC_RELEASE_LESS_THAN(3, 12, 0)
  if (!_app.isUltimateMaster())
    LibmeshPetscCall(PetscOptionsPop());
#endif
}

Referenced by FEProblemSolve::solve().

◆ solverParams() [1/2]

SolverParams & FEProblemBase::solverParams ( unsigned int solver_sys_num = 0 )

Get the solver parameters.

Definition at line 9661 of file FEProblemBase.C.

{
  mooseAssert(solver_sys_num < numSolverSystems(),
              "Solver system number '" << solver_sys_num << "' is out of bounds. We have '"
                                       << numSolverSystems() << "' solver systems");
  return _solver_params[solver_sys_num];
}

Referenced by NonlinearEigenSystem::attachPreconditioner(), SolverSystem::compute(), SlepcEigenSolverConfiguration::configure_solver(), EigenProblemSolve::EigenProblemSolve(), ExplicitTimeIntegrator::ExplicitTimeIntegrator(), FEProblemSolve::FEProblemSolve(), EigenProblem::init(), init(), ExplicitTimeIntegrator::init(), EigenProblemSolve::initialSetup(), EigenProblem::isNonlinearEigenvalueSolver(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionA(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionAB(), Moose::SlepcSupport::mooseSlepcEigenFormFunctionB(), Moose::SlepcSupport::mooseSlepcEigenFormJacobianA(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), ConsoleUtils::outputExecutionInformation(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), NonlinearSystem::residualAndJacobianTogether(), Moose::SlepcSupport::setEigenProblemSolverParams(), Moose::PetscSupport::setLineSearchFromParams(), Moose::PetscSupport::setMFFDTypeFromParams(), Moose::PetscSupport::setSinglePetscOption(), Moose::PetscSupport::setSolveTypeFromParams(), NonlinearSystemBase::shouldEvaluatePreSMOResidual(), EigenProblem::solve(), solverParams(), solverTypeString(), EigenProblem::solverTypeString(), and Moose::SlepcSupport::storeSolveType().

◆ solverParams() [2/2]

const SolverParams & FEProblemBase::solverParams ( unsigned int solver_sys_num = 0 ) const

const version

Definition at line 9670 of file FEProblemBase.C.

{
  return const_cast<FEProblemBase *>(this)->solverParams(solver_sys_num);
}

◆ solverSysNum()

unsigned int FEProblemBase::solverSysNum ( const SolverSystemName & solver_sys_name ) const

overridevirtual

Returns: the solver system number corresponding to the provided solver_sys_name

Implements SubProblem.

Definition at line 7211 of file FEProblemBase.C.

{
  std::istringstream ss(solver_sys_name);
  unsigned int solver_sys_num;
  if (!(ss >> solver_sys_num) || !ss.eof())
  {
    const auto & search = _solver_sys_name_to_num.find(solver_sys_name);
    if (search == _solver_sys_name_to_num.end())
      mooseError("The solver system number was requested for system '" + solver_sys_name,
                 "' but this system does not exist in the Problem. Systems can be added to the "
                 "problem using the 'nl_sys_names'/'linear_sys_names' parameter.\nSystems in the "
                 "Problem: " +
                     Moose::stringify(_solver_sys_names));
    solver_sys_num = search->second;
  }
 
  return solver_sys_num;
}

Referenced by addVariable(), getSystemBase(), PhysicsBase::initializePhysics(), MultiSystemSolveObject::MultiSystemSolveObject(), and DisplacedProblem::solverSysNum().

◆ solverSystemConverged()

bool FEProblemBase::solverSystemConverged ( const unsigned int sys_num )

overridevirtual

Returns: whether the given solver system sys_num is converged

Reimplemented from SubProblem.

Reimplemented in EigenProblem.

Definition at line 7443 of file FEProblemBase.C.

{
  if (_solve)
    return _solver_systems[sys_num]->converged();
  else
    return true;
}

◆ solverTypeString()

std::string FEProblemBase::solverTypeString ( unsigned int solver_sys_num = 0 )

virtual

Return solver type as a human readable string.

Reimplemented in MFEMProblem, and EigenProblem.

Definition at line 10470 of file FEProblemBase.C.

{
  return Moose::stringify(solverParams(solver_sys_num)._type);
}

Referenced by ConsoleUtils::outputExecutionInformation().

◆ startedInitialSetup()

virtual bool FEProblemBase::startedInitialSetup ( )

inlinevirtual

Returns true if we are in or beyond the initialSetup stage.

Definition at line 569 of file FEProblemBase.h.

569{ return _started_initial_setup; }

Referenced by MaterialBase::checkExecutionStage(), MaterialPropertyInterface::checkExecutionStage(), and NEML2ModelExecutor::checkExecutionStage().

◆ storeBoundaryDelayedCheckMatProp()

void SubProblem::storeBoundaryDelayedCheckMatProp	(	const std::string &	requestor,
		BoundaryID	boundary_id,
		const std::string &	name
	)

virtualinherited

Adds to a map based on boundary ids of material properties to validate.

Parameters

requestor	The MOOSE object name requesting the material property
boundary_id	The block id for the MaterialProperty
name	The name of the property

Definition at line 607 of file SubProblem.C.

{
  _map_boundary_material_props_check[boundary_id].insert(std::make_pair(requestor, name));
}

Referenced by MaterialPropertyInterface::checkMaterialProperty().

◆ storeBoundaryMatPropName()

void SubProblem::storeBoundaryMatPropName	(	BoundaryID	boundary_id,
		const std::string &	name
	)

virtualinherited

Adds the given material property to a storage map based on boundary ids.

This is method is called from within the Material class when the property is first registered.

Parameters

boundary_id	The block id for the MaterialProperty
name	The name of the property

Definition at line 581 of file SubProblem.C.

{
  _map_boundary_material_props[boundary_id].insert(name);
}

Referenced by MaterialBase::registerPropName().

◆ storeBoundaryZeroMatProp()

void SubProblem::storeBoundaryZeroMatProp	(	BoundaryID	boundary_id,
		const MaterialPropertyName &	name
	)

virtualinherited

Adds to a map based on boundary ids of material properties for which a zero value can be returned.

Thes properties are optional and will not trigger a missing material property error.

Parameters

boundary_id	The block id for the MaterialProperty
name	The name of the property

Definition at line 593 of file SubProblem.C.

{
  _zero_boundary_material_props[boundary_id].insert(name);
}

Referenced by MaterialBase::storeBoundaryZeroMatProp().

◆ storeSubdomainDelayedCheckMatProp()

void SubProblem::storeSubdomainDelayedCheckMatProp	(	const std::string &	requestor,
		SubdomainID	block_id,
		const std::string &	name
	)

virtualinherited

Adds to a map based on block ids of material properties to validate.

Parameters

block_id	The block id for the MaterialProperty
name	The name of the property

Definition at line 599 of file SubProblem.C.

{
  _map_block_material_props_check[block_id].insert(std::make_pair(requestor, name));
}

Referenced by MaterialPropertyInterface::checkMaterialProperty().

◆ storeSubdomainMatPropName()

void SubProblem::storeSubdomainMatPropName	(	SubdomainID	block_id,
		const std::string &	name
	)

virtualinherited

Adds the given material property to a storage map based on block ids.

This is method is called from within the Material class when the property is first registered.

Parameters

block_id	The block id for the MaterialProperty
name	The name of the property

Definition at line 575 of file SubProblem.C.

{
  _map_block_material_props[block_id].insert(name);
}

Referenced by MaterialBase::registerPropName().

◆ storeSubdomainZeroMatProp()

void SubProblem::storeSubdomainZeroMatProp	(	SubdomainID	block_id,
		const MaterialPropertyName &	name
	)

virtualinherited

Adds to a map based on block ids of material properties for which a zero value can be returned.

Thes properties are optional and will not trigger a missing material property error.

Parameters

block_id	The block id for the MaterialProperty
name	The name of the property

Definition at line 587 of file SubProblem.C.

{
  _zero_block_material_props[block_id].insert(name);
}

Referenced by MaterialBase::storeSubdomainZeroMatProp().

◆ subdomainSetup()

void FEProblemBase::subdomainSetup	(	SubdomainID	subdomain,
		const THREAD_ID	tid
	)

virtual

Definition at line 2695 of file FEProblemBase.C.

{
  _all_materials.subdomainSetup(subdomain, tid);
  // Call the subdomain methods of the output system, these are not threaded so only call it once
  if (tid == 0)
    _app.getOutputWarehouse().subdomainSetup();
 
  for (auto & nl : _nl)
    nl->subdomainSetup(subdomain, tid);
 
  // FIXME: call displaced_problem->subdomainSetup() ?
  //        When adding possibility with materials being evaluated on displaced mesh
}

Referenced by ThreadedFaceLoop< RangeType >::subdomainChanged(), ComputeDiracThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), ComputeMarkerThread::subdomainChanged(), ComputeMaterialsObjectThread::subdomainChanged(), ComputeUserObjectsThread::subdomainChanged(), and NonlinearThread::subdomainChanged().

◆ subspaceDim()

unsigned int FEProblemBase::subspaceDim ( const std::string & prefix ) const

inline

Dimension of the subspace spanned by vectors with a given prefix.

Parameters

prefix Prefix of the vectors spanning the subspace.

Definition at line 2356 of file FEProblemBase.h.

  {
    if (_subspace_dim.count(prefix))
      return _subspace_dim.find(prefix)->second;
    else
      return 0;
  }

Referenced by computeNearNullSpace(), computeNullSpace(), and computeTransposeNullSpace().

◆ swapBackMaterials()

void FEProblemBase::swapBackMaterials ( const THREAD_ID tid )

virtual

Definition at line 4541 of file FEProblemBase.C.

{
  auto && elem = _assembly[tid][0]->elem();
  _material_props.getMaterialData(tid).swapBack(*elem);
}

Referenced by NodalPatchRecovery::compute(), LineMaterialSamplerBase< T >::execute(), ComputeElemAuxVarsThread< AuxKernelType >::onElement(), ComputeIndicatorThread::onElement(), ComputeMarkerThread::onElement(), ComputeUserObjectsThread::onElement(), and NonlinearThread::onElement().

◆ swapBackMaterialsFace()

void FEProblemBase::swapBackMaterialsFace ( const THREAD_ID tid )

virtual

Definition at line 4548 of file FEProblemBase.C.

{
  auto && elem = _assembly[tid][0]->elem();
  unsigned int side = _assembly[tid][0]->side();
  _bnd_material_props.getMaterialData(tid).swapBack(*elem, side);
}

Referenced by ComputeUserObjectsThread::onBoundary(), NonlinearThread::onBoundary(), ComputeUserObjectsThread::onInterface(), NonlinearThread::onInterface(), ComputeIndicatorThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), NonlinearThread::onInternalSide(), and ComputeElemAuxBcsThread< AuxKernelType >::operator()().

◆ swapBackMaterialsNeighbor()

void FEProblemBase::swapBackMaterialsNeighbor ( const THREAD_ID tid )

virtual

Definition at line 4556 of file FEProblemBase.C.

{
  // NOTE: this will not work with h-adaptivity
  const Elem * neighbor = _assembly[tid][0]->neighbor();
  unsigned int neighbor_side =
      neighbor ? neighbor->which_neighbor_am_i(_assembly[tid][0]->elem()) : libMesh::invalid_uint;
 
  if (!neighbor)
  {
    if (haveFV())
    {
      // If neighbor is null, then we're on the neighbor side of a mesh boundary, e.g. we're off
      // the mesh in ghost-land. If we're using the finite volume method, then variable values and
      // consequently material properties have well-defined values in this ghost region outside of
      // the mesh and we really do want to reinit our neighbor materials in this case. Since we're
      // off in ghost land it's safe to do swaps with `MaterialPropertyStorage` using the elem and
      // elem_side keys
      neighbor = _assembly[tid][0]->elem();
      neighbor_side = _assembly[tid][0]->side();
      mooseAssert(neighbor, "We should have an appropriate value for elem coming from Assembly");
    }
    else
      mooseError("neighbor is null in Assembly!");
  }
 
  _neighbor_material_props.getMaterialData(tid).swapBack(*neighbor, neighbor_side);
}

Referenced by ComputeUserObjectsThread::onInterface(), NonlinearThread::onInterface(), ComputeIndicatorThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), NonlinearThread::onInternalSide(), and ComputeElemAuxBcsThread< AuxKernelType >::operator()().

◆ systemBaseAuxiliary() [1/2]

const SystemBase & FEProblemBase::systemBaseAuxiliary ( ) const

overridevirtual

Return the auxiliary system object as a base class reference.

Implements SubProblem.

Definition at line 10011 of file FEProblemBase.C.

{
  return *_aux;
}

Referenced by PhysicsBase::copyVariablesFromMesh(), and MFEMProblem::getAuxVariableNames().

◆ systemBaseAuxiliary() [2/2]

SystemBase & FEProblemBase::systemBaseAuxiliary ( )

overridevirtual

Implements SubProblem.

Definition at line 10017 of file FEProblemBase.C.

{
  return *_aux;
}

◆ systemBaseLinear() [1/2]

const SystemBase & FEProblemBase::systemBaseLinear ( unsigned int sys_num ) const

overridevirtual

Get a constant base class reference to a linear system.

Parameters

sys_num The number of the linear system

Implements SubProblem.

Definition at line 9979 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _linear_systems.size(),
              "System number greater than the number of linear systems");
  return *_linear_systems[sys_num];
}

◆ systemBaseLinear() [2/2]

SystemBase & FEProblemBase::systemBaseLinear ( unsigned int sys_num )

overridevirtual

Get a non-constant base class reference to a linear system.

Parameters

sys_num The number of the linear system

Implements SubProblem.

Definition at line 9987 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _linear_systems.size(),
              "System number greater than the number of linear systems");
  return *_linear_systems[sys_num];
}

◆ systemBaseNonlinear() [1/2]

const SystemBase & FEProblemBase::systemBaseNonlinear ( const unsigned int sys_num ) const

overridevirtual

Return the nonlinear system object as a base class reference given the system number.

Implements SubProblem.

Definition at line 9965 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
  return *_nl[sys_num];
}

◆ systemBaseNonlinear() [2/2]

SystemBase & FEProblemBase::systemBaseNonlinear ( const unsigned int sys_num )

overridevirtual

Implements SubProblem.

Definition at line 9972 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
  return *_nl[sys_num];
}

◆ systemBaseSolver() [1/2]

const SystemBase & FEProblemBase::systemBaseSolver ( const unsigned int sys_num ) const

overridevirtual

Return the solver system object as a base class reference given the system number.

Implements SubProblem.

Definition at line 9995 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _solver_systems.size(),
              "System number greater than the number of solver systems");
  return *_solver_systems[sys_num];
}

◆ systemBaseSolver() [2/2]

SystemBase & FEProblemBase::systemBaseSolver ( const unsigned int sys_num )

overridevirtual

Implements SubProblem.

Definition at line 10003 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _solver_systems.size(),
              "System number greater than the number of solver systems");
  return *_solver_systems[sys_num];
}

◆ systemNumForVariable()

unsigned int FEProblemBase::systemNumForVariable ( const VariableName & variable_name ) const

Returns: the system number for the provided variable_name Can be nonlinear or auxiliary

Definition at line 7231 of file FEProblemBase.C.

{
  for (const auto & solver_sys : _solver_systems)
    if (solver_sys->hasVariable(variable_name))
      return solver_sys->number();
  mooseAssert(_aux, "Should have an auxiliary system");
  if (_aux->hasVariable(variable_name))
    return _aux->number();
 
  mooseError("Variable '",
             variable_name,
             "' was not found in any solver (nonlinear/linear) or auxiliary system");
}

Referenced by projectFunctionOnCustomRange(), and ElementSubdomainModifierBase::restoreOverriddenDofValues().

◆ terminateSolve()

virtual void Problem::terminateSolve ( )

inlinevirtualinherited

Allow objects to request clean termination of the solve.

Definition at line 37 of file Problem.h.

37{ _termination_requested = true; };

Referenced by Terminator::execute(), WebServerControl::execute(), and TerminateChainControl::terminate().

◆ theWarehouse()

TheWarehouse & FEProblemBase::theWarehouse ( ) const

inline

Definition at line 2662 of file FEProblemBase.h.

2662{ return _app.theWarehouse(); }

MooseApp::theWarehouse

TheWarehouse & theWarehouse()

Definition MooseApp.h:140

◆ time()

virtual Real & FEProblemBase::time ( ) const

inlinevirtual

Definition at line 574 of file FEProblemBase.h.

574{ return _time; }

Referenced by EigenExecutionerBase::EigenExecutionerBase(), PseudoTimestep::execute(), Times::getCurrentTime(), getTimeFromStateArg(), TimePostprocessor::getValue(), InversePowerMethod::init(), NonlinearEigen::init(), Moose::MFEM::TimeDependentEquationSystemProblemOperator::Init(), SimulationTimes::initialize(), MFEMSteady::MFEMSteady(), JSONOutput::outputReporters(), XMLOutput::outputVectorPostprocessors(), EigenExecutionerBase::postExecute(), ActuallyExplicitEuler::postResidual(), ExplicitSSPRungeKutta::postResidual(), Predictor::shouldApply(), FixedPointSolve::solve(), Moose::MFEM::TimeDependentEquationSystemProblemOperator::Solve(), ActuallyExplicitEuler::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitSSPRungeKutta::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), FixedPointSolve::solveStep(), SteadyBase::SteadyBase(), and NumNonlinearIterations::timestepSetup().

◆ timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string & section_name ) const

protectedinherited

Returns: The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

{
  return _prefix.empty() ? "" : (_prefix + "::") + section_name;
}

Referenced by PerfGraphInterface::registerTimedSection(), and PerfGraphInterface::registerTimedSection().

◆ timeOld()

virtual Real & FEProblemBase::timeOld ( ) const

inlinevirtual

Definition at line 575 of file FEProblemBase.h.

575{ return _time_old; }

Referenced by EigenExecutionerBase::EigenExecutionerBase(), getTimeFromStateArg(), Predictor::shouldApply(), ActuallyExplicitEuler::solve(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitSSPRungeKutta::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), and LStableDirk4::solve().

◆ timeOlder()

virtual Real & FEProblemBase::timeOlder ( ) const

inlinevirtual

The time two steps back.

The solution keeps this state, so a multi-step integrator can ask for it, and a functor evaluated alongside that solution has to be able to ask for the time it belongs to. Only meaningful once two steps have been taken; before that it holds the start time, which is what timeOld() does at the first step too.

Definition at line 582 of file FEProblemBase.h.

582{ return _time_older; }

Referenced by getTimeFromStateArg().

◆ timeStep()

virtual int & FEProblemBase::timeStep ( ) const

inlinevirtual

Definition at line 583 of file FEProblemBase.h.

583{ return _t_step; }

Referenced by NewmarkBeta::computeTimeDerivatives(), EigenExecutionerBase::EigenExecutionerBase(), PseudoTimestep::execute(), NumTimeSteps::getValue(), InversePowerMethod::init(), NonlinearEigen::init(), PseudoTimestep::outputPseudoTimestep(), JSONOutput::outputReporters(), XMLOutput::outputVectorPostprocessors(), EigenExecutionerBase::postExecute(), TransientMultiApp::setupApp(), FixedPointSolve::solveStep(), PseudoTimestep::timestepEXP(), PseudoTimestep::timestepSER(), and RandomData::updateSeeds().

◆ timestepSetup()

void FEProblemBase::timestepSetup ( )

overridevirtual

Reimplemented from SubProblem.

Definition at line 1694 of file FEProblemBase.C.

{
  SubProblem::timestepSetup();
 
  if (_t_step > 1 && _num_grid_steps)
  {
    libMesh::MeshRefinement mesh_refinement(_mesh);
    std::unique_ptr<libMesh::MeshRefinement> displaced_mesh_refinement(nullptr);
    if (_displaced_mesh)
      displaced_mesh_refinement = std::make_unique<libMesh::MeshRefinement>(*_displaced_mesh);
 
    for (MooseIndex(_num_grid_steps) i = 0; i < _num_grid_steps; ++i)
    {
      if (_displaced_problem)
        // If the DisplacedProblem is active, undisplace the DisplacedMesh in preparation for
        // refinement.  We can't safely refine the DisplacedMesh directly, since the Hilbert keys
        // computed on the inconsistenly-displaced Mesh are different on different processors,
        // leading to inconsistent Hilbert keys.  We must do this before the undisplaced Mesh is
        // coarsensed, so that the element and node numbering is still consistent. We also have to
        // make sure this is done during every step of coarsening otherwise different partitions
        // will be generated for the reference and displaced meshes (even for replicated)
        _displaced_problem->undisplaceMesh();
 
      mesh_refinement.uniformly_coarsen();
      if (_displaced_mesh)
        displaced_mesh_refinement->uniformly_coarsen();
 
      // Mark this as an intermediate change because we do not yet want to reinit_systems. E.g. we
      // need things to happen in the following order for the undisplaced problem:
      // u1) EquationSystems::reinit_solutions. This will restrict the solution vectors and then
      //     contract the mesh
      // u2) MooseMesh::meshChanged. This will update the node/side lists and other
      //     things which needs to happen after the contraction
      // u3) GeometricSearchData::reinit. Once the node/side lists are updated we can perform our
      //     geometric searches which will aid in determining sparsity patterns
      //
      // We do these things for the displaced problem (if it exists)
      // d1) EquationSystems::reinit. Restrict the displaced problem vector copies and then contract
      //     the mesh. It's safe to do a full reinit with the displaced because there are no
      //     matrices that sparsity pattern calculations will be conducted for
      // d2) MooseMesh::meshChanged. This will update the node/side lists and other
      //     things which needs to happen after the contraction
      // d3) UpdateDisplacedMeshThread::operator(). Re-displace the mesh using the *displaced*
      //     solution vector copy because we don't know the state of the reference solution vector.
      //     It's safe to use the displaced copy because we are outside of a non-linear solve,
      //     and there is no concern about differences between solution and current_local_solution
      // d4) GeometricSearchData::reinit. With the node/side lists updated and the mesh
      //     re-displaced, we can perform our geometric searches, which will aid in determining the
      //     sparsity pattern of the matrix held by the libMesh::ImplicitSystem held by the
      //     NonlinearSystem held by this
      meshChanged(
          /*intermediate_change=*/true, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
    }
 
    // u4) Now that all the geometric searches have been done (both undisplaced and displaced),
    //     we're ready to update the sparsity pattern
    es().reinit_systems();
  }
 
  _control_warehouse.timestepSetup();
  if (_line_search)
    _line_search->timestepSetup();
 
  // Random interface objects
  for (const auto & it : _random_data_objects)
    it.second->updateSeeds(EXEC_TIMESTEP_BEGIN);
 
  unsigned int n_threads = numThreads();
  for (THREAD_ID tid = 0; tid < n_threads; tid++)
  {
    _all_materials.timestepSetup(tid);
    _functions.timestepSetup(tid);
  }
 
#ifdef MOOSE_KOKKOS_ENABLED
  _kokkos_functions.timestepSetup();
#endif
 
  _aux->timestepSetup();
  for (auto & sys : _solver_systems)
    sys->timestepSetup();
 
  if (_displaced_problem)
    // timestepSetup for displaced systems
    _displaced_problem->timestepSetup();
 
  for (THREAD_ID tid = 0; tid < n_threads; tid++)
  {
    _internal_side_indicators.timestepSetup(tid);
    _indicators.timestepSetup(tid);
    _markers.timestepSetup(tid);
  }
 
  std::vector<UserObject *> userobjs;
  theWarehouse().query().condition<AttribSystem>("UserObject").queryIntoUnsorted(userobjs);
  for (auto obj : userobjs)
    obj->timestepSetup();
 
#ifdef MOOSE_KOKKOS_ENABLED
  {
    std::vector<UserObjectBase *> userobjs;
    theWarehouse().query().condition<AttribSystem>("KokkosUserObject").queryIntoUnsorted(userobjs);
    for (auto obj : userobjs)
      obj->timestepSetup();
  }
#endif
 
  // Timestep setup of output objects
  _app.getOutputWarehouse().timestepSetup();
 
  if (_requires_nonlocal_coupling)
    if (_nonlocal_kernels.hasActiveObjects() || _nonlocal_integrated_bcs.hasActiveObjects())
      _has_nonlocal_coupling = true;
}

Referenced by Eigenvalue::execute(), SteadyBase::execute(), MFEMSteady::execute(), NonlinearEigen::takeStep(), TransientBase::takeStep(), and MFEMTransient::takeStep().

◆ transient()

virtual void FEProblemBase::transient ( bool trans )

inlinevirtual

Definition at line 591 of file FEProblemBase.h.

591{ _transient = trans; }

Referenced by EigenExecutionerBase::EigenExecutionerBase(), and TransientBase::TransientBase().

◆ trustUserCouplingMatrix()

void FEProblemBase::trustUserCouplingMatrix ( )

Whether to trust the user coupling matrix even if we want to do things like be paranoid and create a full coupling matrix.

See https://github.com/idaholab/moose/issues/16395 for detailed background

Definition at line 6959 of file FEProblemBase.C.

{
  if (_coupling != Moose::COUPLING_CUSTOM)
    mooseError("Someone told us (the FEProblemBase) to trust the user coupling matrix, but we "
               "haven't been provided a coupling matrix!");
 
  _trust_user_coupling_matrix = true;
}

Referenced by SingleMatrixPreconditioner::SingleMatrixPreconditioner().

◆ type()

const std::string & MooseBase::type ( ) const

inlineinherited

Get the type of this class.

Returns: the name of the type of this class

Definition at line 93 of file MooseBase.h.

  {
    mooseAssert(_type.size(), "Empty type");
    return _type;
  }

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

Get the class's combined type and name; useful in error handling.

Returns: The type and name of this class in the form '<type()> "<name()>"'.

Definition at line 57 of file MooseBase.C.

{
  return type() + std::string(" \"") + name() + std::string("\"");
}

Referenced by MaterialPropertyStorage::addProperty(), checkUserObjectNameCollision(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< T >::finalize(), ReporterData::getReporterInfo(), MFEMSamplerBase::initialSetup(), MFEMVariableSamplerBase::initialSetup(), WebServerControl::outputMessage(), and Action::timedAct().

◆ uDotDotOldRequested()

virtual bool FEProblemBase::uDotDotOldRequested ( )

inlinevirtual

Get boolean flag to check whether old solution second time derivative needs to be stored.

Definition at line 2738 of file FEProblemBase.h.

  {
    if (_u_dotdot_old_requested && !_u_dotdot_requested)
      mooseError("FEProblemBase: When requesting old second time derivative of solution, current "
                 "second time derivation of solution should also be stored. Please set "
                 "`u_dotdot_requested` to true using setUDotDotRequested.");
    return _u_dotdot_old_requested;
  }

Referenced by SystemBase::addDotVectors().

◆ uDotDotRequested()

virtual bool FEProblemBase::uDotDotRequested ( )

inlinevirtual

Get boolean flag to check whether solution second time derivative needs to be stored.

Definition at line 2724 of file FEProblemBase.h.

2724{ return _u_dotdot_requested; }

Referenced by SystemBase::addDotVectors(), and addTimeIntegrator().

◆ uDotOldRequested()

virtual bool FEProblemBase::uDotOldRequested ( )

inlinevirtual

Get boolean flag to check whether old solution time derivative needs to be stored.

Definition at line 2727 of file FEProblemBase.h.

  {
    if (_u_dot_old_requested && !_u_dot_requested)
      mooseError("FEProblemBase: When requesting old time derivative of solution, current time "
                 "derivative of solution should also be stored. Please set `u_dot_requested` to "
                 "true using setUDotRequested.");
 
    return _u_dot_old_requested;
  }

Referenced by SystemBase::addDotVectors().

◆ uDotRequested()

virtual bool FEProblemBase::uDotRequested ( )

inlinevirtual

Get boolean flag to check whether solution time derivative needs to be stored.

Definition at line 2721 of file FEProblemBase.h.

2721{ return _u_dot_requested; }

Referenced by SystemBase::addDotVectors().

◆ uniformRefine()

void FEProblemBase::uniformRefine ( )

uniformly refine the problem mesh(es).

This will also prolong the the solution, and in order for that to be safe, we can only perform one refinement at a time

Definition at line 10041 of file FEProblemBase.C.

{
  // ResetDisplacedMeshThread::onNode looks up the reference mesh by ID, so we need to make sure
  // we undisplace before adapting the reference mesh
  if (_displaced_problem)
    _displaced_problem->undisplaceMesh();
 
  Adaptivity::uniformRefine(&_mesh, 1);
  if (_displaced_problem)
    Adaptivity::uniformRefine(&_displaced_problem->mesh(), 1);
 
  meshChanged(
      /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/true);
}

Referenced by FEProblemSolve::solve().

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

Returns: The unique name for accessing input parameters of this object in the InputParameterWarehouse

Definition at line 69 of file MooseBase.C.

{
  if (!_pars.have_parameter<std::string>(unique_name_param))
    mooseError("uniqueName(): Object does not have a unique name");
  return MooseObjectName(_pars.get<std::string>(unique_name_param));
}

Referenced by MooseBase::connectControllableParams(), and Action::uniqueActionName().

◆ uniqueParameterName()

MooseObjectParameterName MooseBase::uniqueParameterName ( const std::string & parameter_name ) const

inherited

Returns: The unique parameter name of a valid parameter of this object for accessing parameter controls

Definition at line 63 of file MooseBase.C.

{
  return MooseObjectParameterName(getBase(), name(), parameter_name);
}

◆ updateActiveObjects()

void FEProblemBase::updateActiveObjects ( )

virtual

Update the active objects in the warehouses.

Reimplemented in DumpObjectsProblem.

Definition at line 5745 of file FEProblemBase.C.

{
  TIME_SECTION("updateActiveObjects", 5, "Updating Active Objects");
 
  for (THREAD_ID tid = 0; tid < numThreads(); ++tid)
  {
    for (auto & nl : _nl)
      nl->updateActive(tid);
    _aux->updateActive(tid);
    _indicators.updateActive(tid);
    _internal_side_indicators.updateActive(tid);
    _markers.updateActive(tid);
    _all_materials.updateActive(tid);
    _materials.updateActive(tid);
    _discrete_materials.updateActive(tid);
  }
 
  _control_warehouse.updateActive();
  _multi_apps.updateActive();
  _transient_multi_apps.updateActive();
  _transfers.updateActive();
  _to_multi_app_transfers.updateActive();
  _from_multi_app_transfers.updateActive();
  _between_multi_app_transfers.updateActive();
 
#ifdef MOOSE_KOKKOS_ENABLED
  _kokkos_materials.updateActive();
#endif
}

Referenced by MooseEigenSystem::eigenKernelOnCurrent(), MooseEigenSystem::eigenKernelOnOld(), and FixedPointSolve::solveStep().

◆ updateGeomSearch()

void FEProblemBase::updateGeomSearch ( GeometricSearchData::GeometricSearchType type = GeometricSearchData::ALL )

overridevirtual

Update this object's geometric search data as well as the displaced problem's if it exists.

Implements SubProblem.

Definition at line 8731 of file FEProblemBase.C.

{
  TIME_SECTION("updateGeometricSearch", 3, "Updating Geometric Search");
 
  _geometric_search_data.update(type);
 
  if (_displaced_problem)
    _displaced_problem->updateGeomSearch(type);
}

Referenced by NonlinearSystemBase::augmentSparsity().

◆ updateMaxQps()

void FEProblemBase::updateMaxQps ( )

private

Definition at line 6827 of file FEProblemBase.C.

{
  // Find the maximum number of quadrature points
  {
    MaxQpsThread mqt(*this);
    Threads::parallel_reduce(getCurrentAlgebraicElementRange(), mqt, numThreads());
    _max_qps = mqt.max();
 
    // If we have more shape functions or more quadrature points on
    // another processor, then we may need to handle those elements
    // ourselves later after repartitioning.
    _communicator.max(_max_qps);
  }
 
  unsigned int max_qpts = getMaxQps();
  if (max_qpts > Moose::constMaxQpsPerElem)
    mooseError("Max quadrature points per element assumptions made in some code (e.g.  Coupleable ",
               "and MaterialPropertyInterface classes) have been violated.\n",
               "Complain to Moose developers to have constMaxQpsPerElem increased from ",
               Moose::constMaxQpsPerElem,
               " to ",
               max_qpts);
  for (unsigned int tid = 0; tid < numThreads(); ++tid)
  {
    // the highest available order in libMesh is 43
    _scalar_zero[tid].resize(libMesh::FORTYTHIRD, 0);
    _zero[tid].resize(max_qpts, 0);
    _ad_zero[tid].resize(max_qpts, 0);
    _grad_zero[tid].resize(max_qpts, RealGradient(0.));
    _ad_grad_zero[tid].resize(max_qpts, ADRealGradient(0));
    _second_zero[tid].resize(max_qpts, RealTensor(0.));
    _ad_second_zero[tid].resize(max_qpts, ADRealTensorValue(0));
    _vector_zero[tid].resize(max_qpts, RealGradient(0.));
    _vector_curl_zero[tid].resize(max_qpts, RealGradient(0.));
  }
}

Referenced by bumpAllQRuleOrder(), bumpVolumeQRuleOrder(), and createQRules().

◆ updateMeshXFEM()

bool FEProblemBase::updateMeshXFEM ( )

virtual

Update the mesh due to changing XFEM cuts.

Definition at line 9013 of file FEProblemBase.C.

{
  TIME_SECTION("updateMeshXFEM", 5, "Updating XFEM");
 
  bool updated = false;
  if (haveXFEM())
  {
    if (_xfem->updateHeal())
      // XFEM exodiff tests rely on a given numbering because they cannot use map = true due to
      // having coincident elements. While conceptually speaking we do not need to contract the
      // mesh, we need its call to renumber_nodes_and_elements in order to preserve these tests
      meshChanged(
          /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/false);
 
    updated = _xfem->update(_time, _nl, *_aux);
    if (updated)
    {
      meshChanged(
          /*intermediate_change=*/false, /*contract_mesh=*/true, /*clean_refinement_flags=*/false);
      _xfem->initSolution(_nl, *_aux);
      restoreSolutions();
      _console << "\nXFEM update complete: Mesh modified" << std::endl;
    }
    else
      _console << "\nXFEM update complete: Mesh not modified" << std::endl;
  }
  return updated;
}

Referenced by FixedPointSolve::solveStep().

◆ updateMortarMesh()

void FEProblemBase::updateMortarMesh ( )

virtual

Definition at line 8742 of file FEProblemBase.C.

{
  TIME_SECTION("updateMortarMesh", 5, "Updating Mortar Mesh");
 
  FloatingPointExceptionGuard fpe_guard(_app);
 
  // If any mortar interface's coverage changed, the DoF ghosting and sparsity that
  // AugmentSparsityOnInterface computed from the previous coverage are stale (see
  // reinitBecauseOfGhostingOrNewGeomObjects()'s mortar_changed parameter); refresh them now rather
  // than leaving that to the caller, since this may be called mid-solve where no other reinit
  // follows. Guard on _initialized: this is also called from init() itself, before es().init() has
  // run for the first time, and reinit()ing an EquationSystems that has never been init()ed is not
  // meaningful (init() immediately after will pick up whatever _mortar_data->update() just built).
  if (_mortar_data->update() && _initialized && !currentlyComputingResidual() &&
      !currentlyComputingJacobian())
    reinitBecauseOfGhostingOrNewGeomObjects(/*mortar_changed=*/true);
}

Referenced by computeJacobianTags(), computeResidualAndJacobian(), computeResidualTags(), and init().

◆ updateSolution()

bool FEProblemBase::updateSolution	(	NumericVector< libMesh::Number > &	vec_solution,
		NumericVector< libMesh::Number > &	ghosted_solution
	)

virtual

Update the solution.

Parameters

vec_solution	Local solution vector that gets modified by this method
ghosted_solution	Ghosted solution vector

Returns: true if the solution was modified, false otherwise

Definition at line 8710 of file FEProblemBase.C.

{
  return false;
}

Referenced by computePostCheck().

◆ useHashTableMatrixAssembly()

bool FEProblemBase::useHashTableMatrixAssembly ( ) const

inline

Definition at line 3072 of file FEProblemBase.h.

3072{ return _use_hash_table_matrix_assembly; }

Referenced by NonlinearSystemBase::addConstraint().

◆ useSNESMFReuseBase()

bool FEProblemBase::useSNESMFReuseBase ( )

inline

Return a flag that indicates if we are reusing the vector base.

Definition at line 2675 of file FEProblemBase.h.

2675{ return _snesmf_reuse_base; }

Referenced by NonlinearSystem::potentiallySetupFiniteDifferencing().

◆ validParams()

InputParameters FEProblemBase::validParams ( )

static

Definition at line 163 of file FEProblemBase.C.

{
  InputParameters params = SubProblem::validParams();
  params.addParam<unsigned int>("null_space_dimension", 0, "The dimension of the nullspace");
  params.addParam<unsigned int>(
      "transpose_null_space_dimension", 0, "The dimension of the transpose nullspace");
  params.addParam<unsigned int>(
      "near_null_space_dimension", 0, "The dimension of the near nullspace");
  params.addParam<bool>("solve",
                        true,
                        "Whether or not to actually solve the Nonlinear system.  "
                        "This is handy in the case that all you want to do is "
                        "execute AuxKernels, Transfers, etc. without actually "
                        "solving anything");
  params.addParam<bool>("use_nonlinear",
                        true,
                        "Determines whether to use a Nonlinear vs a "
                        "Eigenvalue system (Automatically determined based "
                        "on executioner)");
  params.addParam<bool>("error_on_jacobian_nonzero_reallocation",
                        "This causes PETSc to error if it had to reallocate memory in the Jacobian "
                        "matrix due to not having enough nonzeros");
  params.addParam<bool>("ignore_zeros_in_jacobian",
                        false,
                        "Do not explicitly store zero values in "
                        "the Jacobian matrix if true");
  params.addParam<bool>("force_restart",
                        false,
                        "EXPERIMENTAL: If true, a sub_app may use a "
                        "restart file instead of using of using the master "
                        "backup file");
  params.addDeprecatedParam<bool>("skip_additional_restart_data",
                                  false,
                                  "True to skip additional data in equation system for restart.",
                                  "This parameter is no longer used, as we do not load additional "
                                  "vectors by default with restart");
  params.addParam<bool>("skip_nl_system_check",
                        false,
                        "True to skip the NonlinearSystem check for work to do (e.g. Make sure "
                        "that there are variables to solve for).");
  params.addParam<bool>("allow_initial_conditions_with_restart",
                        false,
                        "True to allow the user to specify initial conditions when restarting. "
                        "Initial conditions can override any restarted field");
 
  auto coverage_check_description = [](std::string scope, std::string list_param_name)
  {
    return "Controls, if and how a " + scope +
           " subdomain coverage check is performed. "
           "With 'TRUE' or 'ON' all subdomains are checked (the default). Setting 'FALSE' or 'OFF' "
           "will disable the check for all subdomains. "
           "To exclude a predefined set of subdomains 'SKIP_LIST' is to "
           "be used, while the subdomains to skip are to be defined in the parameter '" +
           list_param_name +
           "'. To limit the check to a list of subdomains, 'ONLY_LIST' is to "
           "be used (again, using the parameter '" +
           list_param_name + "').";
  };
 
  params.addParam<std::vector<SubdomainName>>(
      "block",
      {"ANY_BLOCK_ID"},
      "List of subdomains for kernel coverage and material coverage checks. Setting this parameter "
      "is equivalent to setting 'kernel_coverage_block_list' and 'material_coverage_block_list' as "
      "well as using 'ONLY_LIST' as the coverage check mode.");
 
  MooseEnum kernel_coverage_check_modes("FALSE TRUE OFF ON SKIP_LIST ONLY_LIST", "TRUE");
  params.addParam<MooseEnum>("kernel_coverage_check",
                             kernel_coverage_check_modes,
                             coverage_check_description("kernel", "kernel_coverage_block_list"));
  params.addParam<std::vector<SubdomainName>>(
      "kernel_coverage_block_list",
      {},
      "List of subdomains for kernel coverage check. The meaning of this list is controlled by the "
      "parameter 'kernel_coverage_check' (whether this is the list of subdomains to be checked, "
      "not to be checked or not taken into account).");
  params.addParam<bool>(
      "boundary_restricted_node_integrity_check",
      true,
      "Set to false to disable checking of boundary restricted nodal object variable dependencies, "
      "e.g. are the variable dependencies defined on the selected boundaries?");
  params.addParam<bool>("boundary_restricted_elem_integrity_check",
                        true,
                        "Set to false to disable checking of boundary restricted elemental object "
                        "variable dependencies, e.g. are the variable dependencies defined on the "
                        "selected boundaries?");
  params.addParam<bool>(
      "side_uo_interface_mat_prop_integrity_check",
      true,
      "Set to false to disable checking that side user objects do not consume material "
      "properties declared by interface materials on the same boundary.");
  MooseEnum material_coverage_check_modes("FALSE TRUE OFF ON SKIP_LIST ONLY_LIST", "TRUE");
  params.addParam<MooseEnum>(
      "material_coverage_check",
      material_coverage_check_modes,
      coverage_check_description("material", "material_coverage_block_list"));
  params.addParam<std::vector<SubdomainName>>(
      "material_coverage_block_list",
      {},
      "List of subdomains for material coverage check. The meaning of this list is controlled by "
      "the parameter 'material_coverage_check' (whether this is the list of subdomains to be "
      "checked, not to be checked or not taken into account).");
 
  params.addParam<bool>("fv_bcs_integrity_check",
                        true,
                        "Set to false to disable checking of overlapping Dirichlet and Flux BCs "
                        "and/or multiple DirichletBCs per sideset");
 
  params.addParam<bool>(
      "fv_face_integrity_check",
      true,
      "Set to false to disable checking that FV flux boundary conditions and FV interface "
      "kernels are applied to faces with valid variable ownership and interface topology.");
 
  params.addParam<bool>(
      "material_dependency_check", true, "Set to false to disable material dependency check");
  params.addParam<bool>("parallel_barrier_messaging",
                        false,
                        "Displays messaging from parallel "
                        "barrier notifications when executing "
                        "or transferring to/from Multiapps "
                        "(default: false)");
  params.addParam<unsigned int>(
      "num_concurrent_multiapps",
      1,
      "Set greater than 1 to solve the multiapps sharing an 'execution_order_group' "
      "concurrently. Each such multiapp is assigned a disjoint subset of the MPI ranks "
      "(partitioned using their 'min_procs_per_app'/'max_procs_per_app', otherwise evenly), so "
      "they solve at the same time on different ranks. The specific value only acts as an "
      "on/off switch; the number that run at once is set by the ranks available.");
 
  MooseEnum verbosity("false true extra", "false");
  params.addParam<MooseEnum>("verbose_setup",
                             verbosity,
                             "Set to 'true' to have the problem report on any object created. Set "
                             "to 'extra' to also display all parameters.");
  params.addParam<bool>("verbose_multiapps",
                        false,
                        "Set to True to enable verbose screen printing related to MultiApps");
  params.addParam<bool>(
      "verbose_restore",
      false,
      "Set to True to enable verbose screen printing related to solution restoration");
 
  params.addParam<FileNameNoExtension>("restart_file_base",
                                       "File base name used for restart (e.g. "
                                       "<path>/<filebase> or <path>/LATEST to "
                                       "grab the latest file available)");
 
  params.addParam<std::vector<std::vector<TagName>>>(
      "extra_tag_vectors",
      {},
      "Extra vectors to add to the system that can be filled by objects which compute residuals "
      "and Jacobians (Kernels, BCs, etc.) by setting tags on them. The outer index is for which "
      "nonlinear system the extra tag vectors should be added for");
 
  params.addParam<std::vector<std::vector<TagName>>>(
      "not_zeroed_tag_vectors",
      {},
      "Extra vector tags which the sytem will not zero when other vector tags are zeroed. "
      "The outer index is for which nonlinear system the extra tag vectors should be added for");
 
  params.addParam<std::vector<std::vector<TagName>>>(
      "extra_tag_matrices",
      {},
      "Extra matrices to add to the system that can be filled "
      "by objects which compute residuals and Jacobians "
      "(Kernels, BCs, etc.) by setting tags on them. The outer index is for which "
      "nonlinear system the extra tag vectors should be added for");
 
  params.addParam<std::vector<TagName>>(
      "extra_tag_solutions",
      {},
      "Extra solution vectors to add to the system that can be used by "
      "objects for coupling variable values stored in them.");
 
  params.addParam<bool>("previous_nl_solution_required",
                        false,
                        "True to indicate that this calculation requires a solution vector for "
                        "storing the previous nonlinear iteration.");
 
  params.addParam<std::vector<NonlinearSystemName>>(
      "nl_sys_names", std::vector<NonlinearSystemName>{"nl0"}, "The nonlinear system names");
 
  params.addParam<std::vector<LinearSystemName>>("linear_sys_names", {}, "The linear system names");
 
  params.addParam<bool>("check_uo_aux_state",
                        false,
                        "True to turn on a check that no state presents during the evaluation of "
                        "user objects and aux kernels");
 
  params.addPrivateParam<MooseMesh *>("mesh");
 
  params.declareControllable("solve");
 
  params.addParam<bool>(
      "allow_invalid_solution",
      false,
      "Set to true to allow convergence even though the solution has been marked as 'invalid'");
  params.addParam<bool>("show_invalid_solution_console",
                        true,
                        "Set to true to show the invalid solution occurrence summary in console");
  params.addParam<bool>("immediately_print_invalid_solution",
                        false,
                        "Whether or not to report invalid solution warnings at the time the "
                        "warning is produced instead of after the calculation");
 
  params.addParam<bool>(
      "identify_variable_groups_in_nl",
      true,
      "Whether to identify variable groups in nonlinear systems. This affects dof ordering");
 
  params.addParam<bool>(
      "regard_general_exceptions_as_errors",
      false,
      "If we catch an exception during residual/Jacobian evaluaton for which we don't have "
      "specific handling, immediately error instead of allowing the time step to be cut");
 
  params.addParam<bool>("use_hash_table_matrix_assembly",
                        false,
                        "Whether to assemble matrices using hash tables instead of preallocating "
                        "matrix memory. This can be a good option if the sparsity pattern changes "
                        "throughout the course of the simulation.");
  params.addParam<bool>(
      "restore_original_nonzero_pattern",
      "Whether we should reset matrix memory for every Jacobian evaluation. This option is useful "
      "if the sparsity pattern is constantly changing and you are using hash table assembly or if "
      "you wish to continually restore the matrix to the originally preallocated sparsity pattern "
      "computed by relationship managers.");
 
  params.addParamNamesToGroup(
      "skip_nl_system_check kernel_coverage_check kernel_coverage_block_list "
      "boundary_restricted_node_integrity_check "
      "boundary_restricted_elem_integrity_check "
      "side_uo_interface_mat_prop_integrity_check material_coverage_check "
      "material_coverage_block_list fv_bcs_integrity_check fv_face_integrity_check "
      "material_dependency_check check_uo_aux_state error_on_jacobian_nonzero_reallocation",
      "Simulation checks");
  params.addParamNamesToGroup("use_nonlinear previous_nl_solution_required nl_sys_names "
                              "ignore_zeros_in_jacobian identify_variable_groups_in_nl "
                              "use_hash_table_matrix_assembly restore_original_nonzero_pattern",
                              "Nonlinear system(s)");
  params.addParamNamesToGroup(
      "restart_file_base force_restart allow_initial_conditions_with_restart", "Restart");
  params.addParamNamesToGroup(
      "verbose_setup verbose_multiapps verbose_restore parallel_barrier_messaging", "Verbosity");
  params.addParamNamesToGroup(
      "null_space_dimension transpose_null_space_dimension near_null_space_dimension",
      "Null space removal");
  params.addParamNamesToGroup(
      "extra_tag_vectors extra_tag_matrices extra_tag_solutions not_zeroed_tag_vectors",
      "Contribution to tagged field data");
  params.addParamNamesToGroup(
      "allow_invalid_solution show_invalid_solution_console immediately_print_invalid_solution",
      "Solution validity control");
 
  return params;
}

Referenced by DumpObjectsProblem::validParams(), EigenProblem::validParams(), ExternalProblem::validParams(), and FEProblem::validParams().

◆ vectorTagExists() [1/2]

virtual bool SubProblem::vectorTagExists ( const TagID tag_id ) const

inlinevirtualinherited

Check to see if a particular Tag exists.

Reimplemented in DisplacedProblem.

Definition at line 204 of file SubProblem.h.

204{ return tag_id < _vector_tags.size(); }

◆ vectorTagExists() [2/2]

bool SubProblem::vectorTagExists ( const TagName & tag_name ) const

virtualinherited

Check to see if a particular Tag exists by using Tag name.

Reimplemented in DisplacedProblem.

Definition at line 128 of file SubProblem.C.

{
  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
 
  const auto tag_name_upper = MooseUtils::toUpper(tag_name);
  for (const auto & vector_tag : _vector_tags)
    if (vector_tag._name == tag_name_upper)
      return true;
 
  return false;
}

◆ vectorTagName()

TagName SubProblem::vectorTagName ( const TagID tag ) const

virtualinherited

Retrieve the name associated with a TagID.

Reimplemented in DisplacedProblem.

Definition at line 213 of file SubProblem.C.

{
  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
  if (!vectorTagExists(tag_id))
    mooseError("Vector tag with ID ", tag_id, " does not exist");
 
  return _vector_tags[tag_id]._name;
}

Referenced by SystemBase::addVector(), SystemBase::closeTaggedVector(), NonlinearSystemBase::getResidualNonTimeVector(), NonlinearSystemBase::getResidualTimeVector(), SystemBase::removeVector(), NonlinearSystemBase::residualGhosted(), DisplacedProblem::vectorTagName(), and SystemBase::zeroTaggedVector().

◆ vectorTagNotZeroed()

bool SubProblem::vectorTagNotZeroed ( const TagID tag ) const

inherited

Checks if a vector tag is in the list of vectors that will not be zeroed when other tagged vectors are.

Parameters

tag	the TagID of the vector that is currently being checked

Returns: false if the tag is not within the set of vectors that are intended to not be zero or if the set is empty. returns true otherwise

Definition at line 147 of file SubProblem.C.

{
  return _not_zeroed_tagged_vectors.count(tag);
}

Referenced by SystemBase::zeroTaggedVector().

◆ vectorTagType()

Moose::VectorTagType SubProblem::vectorTagType ( const TagID tag_id ) const

virtualinherited

Reimplemented in DisplacedProblem.

Definition at line 223 of file SubProblem.C.

{
  mooseAssert(verifyVectorTags(), "Vector tag storage invalid");
  if (!vectorTagExists(tag_id))
    mooseError("Vector tag with ID ", tag_id, " does not exist");
 
  return _vector_tags[tag_id]._type;
}

Referenced by MooseVariableScalar::reinit(), TaggingInterface::TaggingInterface(), TagVectorAux::TagVectorAux(), and DisplacedProblem::vectorTagType().

◆ verboseMultiApps()

bool FEProblemBase::verboseMultiApps ( ) const

inline

Whether or not to use verbose printing for MultiApps.

Definition at line 2322 of file FEProblemBase.h.

2322{ return _verbose_multiapps; }

Referenced by MultiApp::backup(), MultiApp::createApp(), MultiApp::restore(), FullSolveMultiApp::showStatusMessage(), and TransientMultiApp::solveStep().

◆ verifyVectorTags()

bool SubProblem::verifyVectorTags ( ) const

protectedinherited

Verify the integrity of _vector_tags and _typed_vector_tags.

Definition at line 233 of file SubProblem.C.

{
  for (TagID tag_id = 0; tag_id < _vector_tags.size(); ++tag_id)
  {
    const auto & vector_tag = _vector_tags[tag_id];
 
    if (vector_tag._id != tag_id)
      mooseError("Vector tag ", vector_tag._id, " id mismatch in _vector_tags");
    if (vector_tag._type == Moose::VECTOR_TAG_ANY)
      mooseError("Vector tag '", vector_tag._name, "' has type VECTOR_TAG_ANY");
 
    const auto search = _vector_tags_name_map.find(vector_tag._name);
    if (search == _vector_tags_name_map.end())
      mooseError("Vector tag ", vector_tag._id, " is not in _vector_tags_name_map");
    else if (search->second != tag_id)
      mooseError("Vector tag ", vector_tag._id, " has incorrect id in _vector_tags_name_map");
 
    unsigned int found_in_type = 0;
    for (TagTypeID tag_type_id = 0; tag_type_id < _typed_vector_tags[vector_tag._type].size();
         ++tag_type_id)
    {
      const auto & vector_tag_type = _typed_vector_tags[vector_tag._type][tag_type_id];
      if (vector_tag_type == vector_tag)
      {
        ++found_in_type;
        if (vector_tag_type._type_id != tag_type_id)
          mooseError("Type ID for Vector tag ", tag_id, " is incorrect");
      }
    }
 
    if (found_in_type == 0)
      mooseError("Vector tag ", tag_id, " not found in _typed_vector_tags");
    if (found_in_type > 1)
      mooseError("Vector tag ", tag_id, " found multiple times in _typed_vector_tags");
  }
 
  unsigned int num_typed_vector_tags = 0;
  for (const auto & typed_vector_tags : _typed_vector_tags)
    num_typed_vector_tags += typed_vector_tags.size();
  if (num_typed_vector_tags != _vector_tags.size())
    mooseError("Size mismatch between _vector_tags and _typed_vector_tags");
  if (_vector_tags_name_map.size() != _vector_tags.size())
    mooseError("Size mismatch between _vector_tags and _vector_tags_name_map");
 
  return true;
}

Referenced by SubProblem::addVectorTag(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), SubProblem::getVectorTags(), SubProblem::getVectorTags(), SubProblem::numVectorTags(), SubProblem::vectorTagExists(), SubProblem::vectorTagName(), and SubProblem::vectorTagType().

Friends And Related Symbol Documentation

◆ AuxiliarySystem

friend class AuxiliarySystem

friend

Definition at line 3702 of file FEProblemBase.h.

◆ DisplacedProblem

friend class DisplacedProblem

friend

Definition at line 3707 of file FEProblemBase.h.

◆ Moose::PetscSupport::setSinglePetscOption

void Moose::PetscSupport::setSinglePetscOption	(	const std::string &	name,
		const std::string &	value,
		FEProblemBase *const	problem
	)

friend

◆ MooseEigenSystem

friend class MooseEigenSystem

friend

Definition at line 3704 of file FEProblemBase.h.

◆ NonlinearSystemBase

friend class NonlinearSystemBase

friend

Definition at line 3703 of file FEProblemBase.h.

◆ Restartable

friend class Restartable

friend

Definition at line 3706 of file FEProblemBase.h.

◆ Resurrector

friend class Resurrector

friend

Definition at line 3705 of file FEProblemBase.h.

Member Data Documentation

◆ _action_factory

ActionFactory& ParallelParamObject::_action_factory

protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

Referenced by AddActionComponentAction::act(), CreateMeshSetupActionsForComponents::act(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), CreateExecutionerAction::setupAutoPreconditioning(), and ReadExecutorParamsAction::setupAutoPreconditioning().

◆ _active_elemental_moose_variables

std::vector<std::set<MooseVariableFieldBase *> > SubProblem::_active_elemental_moose_variables

protectedinherited

This is the set of MooseVariableFieldBase that will actually get reinited by a call to reinit(elem)

Definition at line 1076 of file SubProblem.h.

Referenced by SubProblem::clearActiveElementalMooseVariables(), SubProblem::getActiveElementalMooseVariables(), SubProblem::setActiveElementalMooseVariables(), and SubProblem::SubProblem().

◆ _active_fe_var_coupleable_matrix_tags

std::vector<std::set<TagID> > SubProblem::_active_fe_var_coupleable_matrix_tags

protectedinherited

Definition at line 1082 of file SubProblem.h.

Referenced by SubProblem::clearActiveFEVariableCoupleableMatrixTags(), SubProblem::getActiveFEVariableCoupleableMatrixTags(), SubProblem::setActiveFEVariableCoupleableMatrixTags(), and SubProblem::SubProblem().

◆ _active_fe_var_coupleable_vector_tags

std::vector<std::set<TagID> > SubProblem::_active_fe_var_coupleable_vector_tags

protectedinherited

Definition at line 1084 of file SubProblem.h.

Referenced by SubProblem::clearActiveFEVariableCoupleableVectorTags(), SubProblem::getActiveFEVariableCoupleableVectorTags(), SubProblem::setActiveFEVariableCoupleableVectorTags(), and SubProblem::SubProblem().

◆ _active_sc_var_coupleable_matrix_tags

std::vector<std::set<TagID> > SubProblem::_active_sc_var_coupleable_matrix_tags

protectedinherited

Definition at line 1086 of file SubProblem.h.

Referenced by SubProblem::clearActiveScalarVariableCoupleableMatrixTags(), SubProblem::getActiveScalarVariableCoupleableMatrixTags(), SubProblem::setActiveScalarVariableCoupleableMatrixTags(), and SubProblem::SubProblem().

◆ _active_sc_var_coupleable_vector_tags

std::vector<std::set<TagID> > SubProblem::_active_sc_var_coupleable_vector_tags

protectedinherited

Definition at line 1088 of file SubProblem.h.

Referenced by SubProblem::clearActiveScalarVariableCoupleableVectorTags(), SubProblem::getActiveScalarVariableCoupleableVectorTags(), SubProblem::setActiveScalarVariableCoupleableVectorTags(), and SubProblem::SubProblem().

◆ _ad_grad_zero

std::vector<MooseArray<ADRealVectorValue> > FEProblemBase::_ad_grad_zero

Definition at line 2607 of file FEProblemBase.h.

Referenced by FEProblemBase(), updateMaxQps(), and ~FEProblemBase().

◆ _ad_second_zero

std::vector<MooseArray<ADRealTensorValue> > FEProblemBase::_ad_second_zero

Definition at line 2610 of file FEProblemBase.h.

Referenced by FEProblemBase(), updateMaxQps(), and ~FEProblemBase().

◆ _ad_zero

std::vector<MooseArray<ADReal> > FEProblemBase::_ad_zero

Definition at line 2605 of file FEProblemBase.h.

Referenced by FEProblemBase(), updateMaxQps(), and ~FEProblemBase().

◆ _adaptivity

Adaptivity FEProblemBase::_adaptivity

protected

Definition at line 3425 of file FEProblemBase.h.

Referenced by adaptivity(), adaptMesh(), addAnyRedistributers(), checkProblemIntegrity(), computeMarkers(), hasInitialAdaptivity(), and initialAdaptMesh().

◆ _all_materials

MaterialWarehouse FEProblemBase::_all_materials

protected

Definition at line 3318 of file FEProblemBase.h.

Referenced by addFunctorMaterial(), addMaterialHelper(), checkProblemIntegrity(), computeBounds(), computeJacobianTags(), computeResidualAndJacobian(), computeResidualTags(), customSetup(), getMaterial(), getMaterialWarehouse(), neighborSubdomainSetup(), prepareMaterials(), setActiveMaterialProperties(), subdomainSetup(), timestepSetup(), and updateActiveObjects().

◆ _allow_ics_during_restart

const bool FEProblemBase::_allow_ics_during_restart

private

Definition at line 3677 of file FEProblemBase.h.

Referenced by checkICRestartError().

◆ _allow_invalid_solution

const bool FEProblemBase::_allow_invalid_solution

private

Definition at line 3680 of file FEProblemBase.h.

Referenced by allowInvalidSolution().

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

◆ _assembly

std::vector<std::vector<std::unique_ptr<Assembly> > > FEProblemBase::_assembly

protected

The Assembly objects.

The first index corresponds to the thread ID and the second index corresponds to the nonlinear system number

Definition at line 3268 of file FEProblemBase.h.

Referenced by addCachedResidualDirectly(), addJacobian(), addJacobianBlockTags(), addJacobianLowerD(), addJacobianNeighbor(), addJacobianNeighborLowerD(), addJacobianOffDiagScalar(), addJacobianScalar(), addResidual(), addResidualLower(), addResidualNeighbor(), addResidualScalar(), assembly(), assembly(), bumpAllQRuleOrder(), bumpVolumeQRuleOrder(), couplingEntries(), createQRules(), fieldScalarCouplingEntries(), init(), initElementStatefulProps(), initXFEM(), meshChanged(), newAssemblyArray(), nonlocalCouplingEntries(), prepare(), prepare(), prepareAssembly(), prepareAssemblyNeighbor(), prepareFaceShapes(), prepareNeighborShapes(), prepareShapes(), reinitDirac(), reinitElemFace(), reinitElemNeighborAndLowerD(), reinitElemPhys(), reinitMaterials(), reinitMaterialsBoundary(), reinitMaterialsFace(), reinitMaterialsFaceOnBoundary(), reinitMaterialsInterface(), reinitMaterialsNeighbor(), reinitNeighbor(), reinitNeighborPhys(), reinitNeighborPhys(), reinitNode(), reinitNodeFace(), reinitOffDiagScalars(), reinitScalars(), setCurrentSubdomainID(), setNeighborSubdomainID(), setNeighborSubdomainID(), setResidual(), setResidualNeighbor(), swapBackMaterials(), swapBackMaterialsFace(), and swapBackMaterialsNeighbor().

◆ _aux

std::shared_ptr<AuxiliarySystem> FEProblemBase::_aux

protected

The auxiliary system.

Definition at line 3251 of file FEProblemBase.h.

Referenced by addAuxArrayVariable(), addAuxKernel(), addAuxScalarKernel(), addAuxScalarVariable(), addAuxVariable(), addIndicator(), addMarker(), addMultiApp(), addObjectParamsHelper(), addTimeIntegrator(), addTransfer(), advanceState(), checkExceptionAndStopSolve(), computeBounds(), computeIndicators(), computeJacobianTags(), computeLinearSystemTags(), computeMarkers(), computePostCheck(), computeResidualAndJacobian(), computeResidualTags(), computeSystems(), computeUserObjectsInternal(), copySolutionsBackwards(), createQRules(), createTagMatrices(), createTagSolutions(), customSetup(), determineSolverSystem(), DumpObjectsProblem::DumpObjectsProblem(), duplicateVariableCheck(), EigenProblem::EigenProblem(), execute(), ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), getActualFieldVariable(), getArrayVariable(), getAuxiliarySystem(), getScalarVariable(), getStandardVariable(), getSystem(), getSystemBase(), getSystemBase(), getSystemBase(), getVariable(), getVariableNames(), getVectorVariable(), hasScalarVariable(), hasSolutionState(), hasVariable(), init(), initialSetup(), meshChanged(), needBoundaryMaterialOnSide(), needSolutionState(), outputStep(), prepare(), prepare(), prepareFace(), projectInitialConditionOnCustomRange(), projectSolution(), reinitDirac(), reinitElem(), reinitElemFace(), reinitElemPhys(), reinitNeighbor(), reinitNeighborPhys(), reinitNeighborPhys(), reinitNode(), reinitNodeFace(), reinitScalars(), restoreOldSolutions(), restoreSolutions(), saveOldSolutions(), setAuxKernelParamsAndLog(), skipNextForwardSolutionCopyToOld(), systemBaseAuxiliary(), systemBaseAuxiliary(), systemNumForVariable(), timestepSetup(), updateActiveObjects(), and updateMeshXFEM().

◆ _aux_evaluable_local_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_aux_evaluable_local_elem_range

protected

Definition at line 3579 of file FEProblemBase.h.

◆ _between_multi_app_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_between_multi_app_transfers

protected

Transfers executed just before MultiApps to transfer data between them.

Definition at line 3353 of file FEProblemBase.h.

Referenced by addTransfer(), execMultiAppTransfers(), getMultiAppTransferWarehouse(), getTransfers(), getTransfers(), and updateActiveObjects().

◆ _block_mat_side_cache

std::vector<std::unordered_map<SubdomainID, bool> > FEProblemBase::_block_mat_side_cache

protected

Cache for calculating materials on side.

Definition at line 3362 of file FEProblemBase.h.

Referenced by FEProblemBase(), and needInternalNeighborSideMaterial().

◆ _bnd_mat_side_cache

std::vector<std::unordered_map<BoundaryID, bool> > FEProblemBase::_bnd_mat_side_cache

protected

Cache for calculating materials on side.

Definition at line 3365 of file FEProblemBase.h.

Referenced by FEProblemBase(), and needBoundaryMaterialOnSide().

◆ _bnd_material_props

MaterialPropertyStorage& FEProblemBase::_bnd_material_props

protected

Definition at line 3305 of file FEProblemBase.h.

Referenced by addAnyRedistributers(), advanceState(), checkProblemIntegrity(), getBndMaterialPropertyStorage(), getMaterialData(), getMaterialPropertyStorageConsumers(), initElementStatefulProps(), initXFEM(), meshChanged(), reinitMaterialsBoundary(), reinitMaterialsFace(), reinitMaterialsFaceOnBoundary(), reinitMaterialsInterface(), and swapBackMaterialsFace().

◆ _boundary_restricted_elem_integrity_check

const bool FEProblemBase::_boundary_restricted_elem_integrity_check

protected

whether to perform checking of boundary restricted elemental object variable dependencies, e.g.

whether the variable dependencies are defined on the selected boundaries

Definition at line 3507 of file FEProblemBase.h.

◆ _boundary_restricted_node_integrity_check

const bool FEProblemBase::_boundary_restricted_node_integrity_check

protected

whether to perform checking of boundary restricted nodal object variable dependencies, e.g.

whether the variable dependencies are defined on the selected boundaries

Definition at line 3503 of file FEProblemBase.h.

◆ _calculate_jacobian_in_uo

bool FEProblemBase::_calculate_jacobian_in_uo

protected

Definition at line 3488 of file FEProblemBase.h.

Referenced by checkNonlocalCoupling(), EigenProblem::computeJacobian(), and meshChanged().

◆ _check_residual_for_nans

bool FEProblemBase::_check_residual_for_nans

protected

Whether to check the residual for NaN or Inf values.

Definition at line 3530 of file FEProblemBase.h.

Referenced by checkResidualForNans(), and setCheckResidualForNans().

◆ _checking_uo_aux_state

bool FEProblemBase::_checking_uo_aux_state = false

private

Flag used to indicate whether we are doing the uo/aux state check in execute.

Definition at line 3726 of file FEProblemBase.h.

Referenced by checkingUOAuxState(), and execute().

◆ _cli_option_found

bool Problem::_cli_option_found

protectedinherited

True if the CLI option is found.

Definition at line 52 of file Problem.h.

Referenced by Problem::_setCLIOption().

◆ _cm

std::vector<std::unique_ptr<libMesh::CouplingMatrix> > FEProblemBase::_cm

protected

Coupling matrix for variables.

Definition at line 3254 of file FEProblemBase.h.

Referenced by areCoupled(), couplingMatrix(), FEProblemBase(), and init().

◆ _color_output

bool Problem::_color_output

protectedinherited

True if we're going to attempt to write color output.

Definition at line 55 of file Problem.h.

◆ _computing_nonlinear_residual

bool SubProblem::_computing_nonlinear_residual

protectedinherited

Whether the non-linear residual is being evaluated.

Definition at line 1103 of file SubProblem.h.

Referenced by SubProblem::computingNonlinearResid(), computingNonlinearResid(), and SubProblem::computingNonlinearResid().

◆ _computing_scaling_jacobian

bool FEProblemBase::_computing_scaling_jacobian = false

private

Flag used to indicate whether we are computing the scaling Jacobian.

Definition at line 3720 of file FEProblemBase.h.

Referenced by computingScalingJacobian(), and computingScalingJacobian().

◆ _computing_scaling_residual

bool FEProblemBase::_computing_scaling_residual = false

private

Flag used to indicate whether we are computing the scaling Residual.

Definition at line 3723 of file FEProblemBase.h.

Referenced by computingScalingResidual(), and computingScalingResidual().

◆ _console

const ConsoleStream ConsoleStreamInterface::_console

inherited

An instance of helper class to write streams to the Console objects.

Definition at line 31 of file ConsoleStreamInterface.h.

◆ _const_jacobian

bool FEProblemBase::_const_jacobian

protected

true if the Jacobian is constant

Definition at line 3467 of file FEProblemBase.h.

Referenced by computeJacobianTags(), constJacobian(), prepare(), and setConstJacobian().

◆ _consumed_material_properties

std::map<MooseObjectName, std::set<std::string> > SubProblem::_consumed_material_properties

privateinherited

Definition at line 1189 of file SubProblem.h.

Referenced by SubProblem::addConsumedPropertyName(), and SubProblem::getConsumedPropertyMap().

◆ _control_warehouse

ExecuteMooseObjectWarehouse<Control> FEProblemBase::_control_warehouse

protected

The control logic warehouse.

Definition at line 3564 of file FEProblemBase.h.

Referenced by executeControls(), getControlWarehouse(), timestepSetup(), and updateActiveObjects().

◆ _convergences

MooseObjectWarehouse<Convergence> FEProblemBase::_convergences

protected

convergence warehouse

Definition at line 3287 of file FEProblemBase.h.

Referenced by addConvergence(), getConvergence(), getConvergenceObjects(), and hasConvergence().

◆ _coupling

Moose::CouplingType FEProblemBase::_coupling

protected

Type of variable coupling.

Definition at line 3253 of file FEProblemBase.h.

Referenced by coupling(), init(), setCoupling(), and trustUserCouplingMatrix().

◆ _current_algebraic_bnd_node_range

std::unique_ptr<ConstBndNodeRange> FEProblemBase::_current_algebraic_bnd_node_range

protected

Definition at line 3583 of file FEProblemBase.h.

Referenced by getCurrentAlgebraicBndNodeRange(), and setCurrentAlgebraicBndNodeRange().

◆ _current_algebraic_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_current_algebraic_elem_range

protected

Definition at line 3581 of file FEProblemBase.h.

Referenced by getCurrentAlgebraicElementRange(), and setCurrentAlgebraicElementRange().

◆ _current_algebraic_node_range

std::unique_ptr<libMesh::ConstNodeRange> FEProblemBase::_current_algebraic_node_range

protected

Definition at line 3582 of file FEProblemBase.h.

Referenced by getCurrentAlgebraicNodeRange(), and setCurrentAlgebraicNodeRange().

◆ _current_execute_on_flag

ExecFlagType FEProblemBase::_current_execute_on_flag

protected

Current execute_on flag.

Definition at line 3561 of file FEProblemBase.h.

Referenced by checkExceptionAndStopSolve(), computeJacobianTags(), computeLinearSystemTags(), computePostCheck(), computeResidualAndJacobian(), computeResidualTags(), computeUserObjectByName(), computeUserObjects(), getCurrentExecuteOnFlag(), joinAndFinalize(), resetState(), setCurrentExecuteOnFlag(), and shouldPrintExecution().

◆ _current_ic_state

unsigned short FEProblemBase::_current_ic_state

protected

Definition at line 3590 of file FEProblemBase.h.

Referenced by getCurrentICState().

◆ _current_linear_sys

LinearSystem* FEProblemBase::_current_linear_sys

protected

The current linear system that we are solving.

Definition at line 3215 of file FEProblemBase.h.

Referenced by checkExceptionAndStopSolve(), computeLinearSystemSys(), computeLinearSystemTags(), computeResidualL2Norm(), currentLinearSystem(), currentLinearSystem(), setCurrentLinearSystem(), and solveLinearSystem().

◆ _current_nl_sys

NonlinearSystemBase* FEProblemBase::_current_nl_sys

protected

The current nonlinear system that we are solving.

Definition at line 3233 of file FEProblemBase.h.

Referenced by addCachedResidualDirectly(), addJacobian(), addJacobianBlockTags(), addJacobianLowerD(), addJacobianNeighbor(), addJacobianNeighborLowerD(), addJacobianOffDiagScalar(), addJacobianScalar(), addResidual(), addResidualLower(), addResidualNeighbor(), addResidualScalar(), checkExceptionAndStopSolve(), computeBounds(), computeDamping(), computeJacobianBlock(), computeJacobianBlocks(), EigenProblem::computeJacobianBlocks(), computeJacobianInternal(), computeJacobianTag(), computeJacobianTags(), computeNearNullSpace(), computeNullSpace(), computePostCheck(), computeResidualAndJacobian(), computeResidualInternal(), computeResidualL2Norm(), computeResidualTag(), computeResidualTags(), computeResidualType(), computeTransposeNullSpace(), currentNonlinearSystem(), currentNonlinearSystem(), EigenProblem::doFreeNonlinearPowerIterations(), EigenProblem::EigenProblem(), prepare(), prepareAssembly(), prepareAssemblyNeighbor(), prepareFaceShapes(), prepareNeighborShapes(), prepareShapes(), reinitDirac(), reinitNeighborPhys(), reinitNeighborPhys(), reinitOffDiagScalars(), setCurrentNonlinearSystem(), setResidual(), setResidualNeighbor(), solve(), and EigenProblem::solve().

◆ _current_residual_vector_tags

std::vector<VectorTag> FEProblemBase::_current_residual_vector_tags

private

A data member to store the residual vector tag(s) passed into computeResidualTag(s).

This data member will be used when APIs like cacheResidual, addCachedResiduals, etc. are called

Definition at line 3737 of file FEProblemBase.h.

Referenced by clearCurrentResidualVectorTags(), currentResidualVectorTags(), and setCurrentResidualVectorTags().

◆ _current_solver_sys

SolverSystem* FEProblemBase::_current_solver_sys

protected

The current solver system.

Definition at line 3236 of file FEProblemBase.h.

Referenced by setCurrentLinearSystem(), and setCurrentNonlinearSystem().

◆ _currently_computing_jacobian

bool SubProblem::_currently_computing_jacobian

protectedinherited

Flag to determine whether the problem is currently computing Jacobian.

Definition at line 1097 of file SubProblem.h.

Referenced by computeJacobianBlocks(), EigenProblem::computeJacobianBlocks(), computeJacobianTags(), SubProblem::currentlyComputingJacobian(), and SubProblem::setCurrentlyComputingJacobian().

◆ _currently_computing_residual

bool SubProblem::_currently_computing_residual

protectedinherited

Whether the residual is being evaluated.

Definition at line 1106 of file SubProblem.h.

Referenced by SubProblem::currentlyComputingResidual(), setCurrentlyComputingResidual(), and SubProblem::setCurrentlyComputingResidual().

◆ _currently_computing_residual_and_jacobian

bool SubProblem::_currently_computing_residual_and_jacobian

protectedinherited

Flag to determine whether the problem is currently computing the residual and Jacobian.

Definition at line 1100 of file SubProblem.h.

Referenced by SubProblem::currentlyComputingResidualAndJacobian(), and SubProblem::setCurrentlyComputingResidualAndJacobian().

◆ _cycles_completed

unsigned int FEProblemBase::_cycles_completed

protected

Definition at line 3426 of file FEProblemBase.h.

Referenced by adaptMesh(), getNumCyclesCompleted(), and initialAdaptMesh().

◆ _default_ghosting

bool SubProblem::_default_ghosting

protectedinherited

Whether or not to use default libMesh coupling.

Definition at line 1091 of file SubProblem.h.

Referenced by SubProblem::defaultGhosting().

◆ _dirac_kernel_info

DiracKernelInfo SubProblem::_dirac_kernel_info

protectedinherited

Definition at line 1050 of file SubProblem.h.

Referenced by DisplacedProblem::clearDiracInfo(), clearDiracInfo(), SubProblem::diracKernelInfo(), DisplacedProblem::getDiracElements(), getDiracElements(), meshChanged(), DisplacedProblem::reinitDirac(), reinitDirac(), DisplacedProblem::updateMesh(), and DisplacedProblem::updateMesh().

◆ _discrete_materials

MaterialWarehouse FEProblemBase::_discrete_materials

protected

Definition at line 3317 of file FEProblemBase.h.

Referenced by addMaterialHelper(), getDiscreteMaterialWarehouse(), reinitMaterials(), reinitMaterialsBoundary(), reinitMaterialsFace(), reinitMaterialsFaceOnBoundary(), reinitMaterialsNeighbor(), and updateActiveObjects().

◆ _displaced_mesh

MooseMesh* FEProblemBase::_displaced_mesh

protected

◆ _displaced_problem

std::shared_ptr<DisplacedProblem> FEProblemBase::_displaced_problem

protected

Definition at line 3434 of file FEProblemBase.h.

Referenced by adaptMesh(), addAnyRedistributers(), addAuxArrayVariable(), addAuxScalarKernel(), addAuxScalarVariable(), addAuxVariable(), addCachedJacobian(), addCachedResidual(), addCachedResidualDirectly(), addConstraint(), addDGKernel(), addDiracKernel(), addDisplacedProblem(), addFunction(), addFunctorMaterial(), addFVKernel(), addGhostedBoundary(), addIndicator(), addInterfaceKernel(), addJacobian(), addJacobianBlockTags(), addJacobianLowerD(), addJacobianNeighbor(), addJacobianNeighborLowerD(), addMarker(), addMaterialHelper(), addMultiApp(), addNodalKernel(), addObjectParamsHelper(), addResidual(), addResidualLower(), addResidualNeighbor(), addScalarKernel(), addTimeIntegrator(), addTransfer(), addUserObject(), addVariable(), advanceState(), automaticScaling(), backupGeometricSearchState(), bumpAllQRuleOrder(), bumpVolumeQRuleOrder(), cacheJacobian(), cacheJacobianNeighbor(), cacheResidual(), cacheResidualNeighbor(), checkDisplacementOrders(), clearActiveElementalMooseVariables(), clearActiveFEVariableCoupleableMatrixTags(), clearActiveFEVariableCoupleableVectorTags(), clearActiveScalarVariableCoupleableMatrixTags(), clearActiveScalarVariableCoupleableVectorTags(), clearDiracInfo(), computeJacobianBlocks(), EigenProblem::computeJacobianBlocks(), computeJacobianTags(), computeResidualAndJacobian(), computeResidualTags(), computeUserObjectsInternal(), computingNonlinearResid(), createMortarInterface(), createQRules(), customSetup(), execute(), getDiracElements(), getDisplacedProblem(), getDisplacedProblem(), getMortarUserObjects(), ghostGhostedBoundaries(), haveADObjects(), haveDisplaced(), init(), initXFEM(), jacobianSetup(), mesh(), mesh(), meshChanged(), outputStep(), possiblyRebuildGeomSearchPatches(), prepare(), prepare(), prepareAssembly(), prepareAssemblyNeighbor(), prepareFace(), reinitBecauseOfGhostingOrNewGeomObjects(), reinitDirac(), reinitElem(), reinitElemFace(), reinitElemFaceRef(), reinitElemNeighborAndLowerD(), reinitLowerDElem(), reinitNeighbor(), reinitNeighborFaceRef(), reinitNode(), reinitNodeFace(), reinitOffDiagScalars(), reinitScalars(), resetState(), residualSetup(), restoreGeometricSearchState(), restoreSolutions(), setActiveElementalMooseVariables(), setActiveFEVariableCoupleableMatrixTags(), setActiveFEVariableCoupleableVectorTags(), setActiveScalarVariableCoupleableMatrixTags(), setActiveScalarVariableCoupleableVectorTags(), setAuxKernelParamsAndLog(), setCurrentBoundaryID(), setCurrentLowerDElem(), setCurrentlyComputingResidual(), setCurrentSubdomainID(), setNeighborSubdomainID(), setNeighborSubdomainID(), setResidual(), setResidualNeighbor(), setResidualObjectParamsAndLog(), solve(), EigenProblem::solve(), timestepSetup(), uniformRefine(), and updateGeomSearch().

◆ _dt

Real& FEProblemBase::_dt

protected

Definition at line 3192 of file FEProblemBase.h.

Referenced by dt(), execMultiApps(), and FEProblemBase().

◆ _dt_old

Real& FEProblemBase::_dt_old

protected

Definition at line 3193 of file FEProblemBase.h.

Referenced by dtOld(), and FEProblemBase().

◆ _enabled

const bool& MooseObject::_enabled

protectedinherited

Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

Definition at line 71 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _error_on_jacobian_nonzero_reallocation

bool FEProblemBase::_error_on_jacobian_nonzero_reallocation

private

Whether to error when the Jacobian is re-allocated, usually because the sparsity pattern changed.

Definition at line 3665 of file FEProblemBase.h.

Referenced by errorOnJacobianNonzeroReallocation(), and setErrorOnJacobianNonzeroReallocation().

◆ _evaluable_local_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_evaluable_local_elem_range

protected

Definition at line 3577 of file FEProblemBase.h.

Referenced by getEvaluableElementRange(), and meshChanged().

◆ _exception_message

std::string FEProblemBase::_exception_message

protected

The error message to go with an exception.

Definition at line 3558 of file FEProblemBase.h.

Referenced by checkExceptionAndStopSolve(), and setException().

◆ _factory

Factory& SubProblem::_factory

protectedinherited

The Factory for building objects.

Definition at line 1048 of file SubProblem.h.

Referenced by addAnyRedistributers(), addAuxArrayVariable(), addAuxScalarVariable(), addConvergence(), addDefaultMultiAppFixedPointConvergence(), addDefaultNonlinearConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), addDefaultSteadyStateConvergence(), addFunction(), MFEMProblem::addFunction(), addFunctorMaterial(), addFVGradientMethod(), addFVInitialCondition(), addFVInterpolationMethod(), addIndicator(), addInitialCondition(), FEProblem::addLineSearch(), addMarker(), addMaterialHelper(), addMeshDivision(), MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), addMultiApp(), addObject(), addOutput(), addPredictor(), addTransfer(), addUserObject(), DumpObjectsProblem::deduceNecessaryParameters(), getFunction(), and getKokkosFunction().

◆ _fail_next_system_convergence_check

bool FEProblemBase::_fail_next_system_convergence_check

private

Definition at line 3679 of file FEProblemBase.h.

Referenced by checkExceptionAndStopSolve(), getFailNextSystemConvergenceCheck(), resetFailNextSystemConvergenceCheck(), setFailNextSystemConvergenceCheck(), and solve().

◆ _fe_matrix_tags

std::set<TagID> FEProblemBase::_fe_matrix_tags

protected

Definition at line 3176 of file FEProblemBase.h.

Referenced by computeJacobian(), EigenProblem::computeJacobianAB(), EigenProblem::computeJacobianTag(), EigenProblem::computeMatricesTags(), and computeResidualAndJacobian().

◆ _fe_vector_tags

std::set<TagID> FEProblemBase::_fe_vector_tags

protected

Definition at line 3174 of file FEProblemBase.h.

Referenced by checkExceptionAndStopSolve(), EigenProblem::computeResidualAB(), computeResidualAndJacobian(), and EigenProblem::computeResidualTag().

◆ _force_restart

const bool FEProblemBase::_force_restart

private

Definition at line 3676 of file FEProblemBase.h.

◆ _from_multi_app_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_from_multi_app_transfers

protected

Transfers executed just after MultiApps to transfer data from them.

Definition at line 3350 of file FEProblemBase.h.

Referenced by addTransfer(), execMultiAppTransfers(), getMultiAppTransferWarehouse(), getTransfers(), getTransfers(), and updateActiveObjects().

◆ _functions

MooseObjectWarehouse<Function> FEProblemBase::_functions

protected

functions

Definition at line 3280 of file FEProblemBase.h.

Referenced by addFunction(), MFEMProblem::addFunction(), computeJacobianTags(), computeLinearSystemTags(), computeResidualAndJacobian(), computeResidualTags(), customSetup(), getFunction(), getFunctionWarehouse(), hasFunction(), DumpObjectsProblem::initialSetup(), and timestepSetup().

◆ _functor_to_request_info

std::vector<std::multimap<std::string, std::pair<bool, bool> > > SubProblem::_functor_to_request_info

privateinherited

A multimap (for each thread) from unfilled functor requests to whether the requests were for AD functors and whether the requestor was an AD object.

Definition at line 1162 of file SubProblem.h.

Referenced by SubProblem::addFunctor(), SubProblem::getFunctor(), and SubProblem::SubProblem().

◆ _functor_to_requestors

std::map<std::string, std::set<std::string> > SubProblem::_functor_to_requestors

privateinherited

The requestors of functors where the key is the prop name and the value is a set of names of requestors.

Definition at line 1158 of file SubProblem.h.

Referenced by SubProblem::getFunctor(), SubProblem::initialSetup(), and SubProblem::showFunctorRequestors().

◆ _functors

std::vector<std::multimap<std::string, std::tuple<TrueFunctorIs, std::unique_ptr<Moose::FunctorEnvelopeBase>, std::unique_ptr<Moose::FunctorEnvelopeBase> > > > SubProblem::_functors

privateinherited

A container holding pointers to all the functors in our problem.

We hold a tuple where the zeroth item in the tuple is an enumerator that describes what type of functor the "true" functor is (either NONAD or AD), the first item in the tuple is the non-AD version of the functor, and the second item in the tuple is the AD version of the functor

Definition at line 1145 of file SubProblem.h.

Referenced by SubProblem::addFunctor(), SubProblem::getFunctor(), SubProblem::hasFunctor(), SubProblem::hasFunctorWithType(), SubProblem::initialSetup(), SubProblem::showFunctors(), and SubProblem::SubProblem().

◆ _fv_bcs_integrity_check

bool FEProblemBase::_fv_bcs_integrity_check

protected

Whether to check overlapping Dirichlet and Flux BCs and/or multiple DirichletBCs per sideset.

Definition at line 3517 of file FEProblemBase.h.

Referenced by fvBCsIntegrityCheck(), and fvBCsIntegrityCheck().

◆ _fv_face_integrity_check

const bool FEProblemBase::_fv_face_integrity_check

protected

Whether to check FV boundary and interface objects against the faces on which they execute.

Definition at line 3520 of file FEProblemBase.h.

◆ _fv_ics

FVInitialConditionWarehouse FEProblemBase::_fv_ics

protected

Definition at line 3298 of file FEProblemBase.h.

Referenced by addFVInitialCondition(), and getFVInitialConditionWarehouse().

◆ _geometric_search_data

GeometricSearchData FEProblemBase::_geometric_search_data

protected

Definition at line 3435 of file FEProblemBase.h.

Referenced by backupGeometricSearchState(), geomSearchData(), meshChanged(), possiblyRebuildGeomSearchPatches(), reinitBecauseOfGhostingOrNewGeomObjects(), restoreGeometricSearchState(), and updateGeomSearch().

◆ _ghosted_elems

std::set<dof_id_type> SubProblem::_ghosted_elems

protectedinherited

Elements that should have Dofs ghosted to the local processor.

Definition at line 1094 of file SubProblem.h.

Referenced by addGhostedElem(), SubProblem::ghostedElems(), meshChanged(), possiblyRebuildGeomSearchPatches(), and reinitBecauseOfGhostingOrNewGeomObjects().

◆ _grad_phi_zero

std::vector<VariablePhiGradient> FEProblemBase::_grad_phi_zero

Definition at line 2608 of file FEProblemBase.h.

Referenced by FEProblemBase(), and ~FEProblemBase().

◆ _grad_zero

std::vector<VariableGradient> FEProblemBase::_grad_zero

Definition at line 2606 of file FEProblemBase.h.

Referenced by FEProblemBase(), reinitDirac(), updateMaxQps(), and ~FEProblemBase().

◆ _has_active_elemental_moose_variables

std::vector<unsigned int> SubProblem::_has_active_elemental_moose_variables

protectedinherited

Whether or not there is currently a list of active elemental moose variables.

Definition at line 1080 of file SubProblem.h.

Referenced by SubProblem::clearActiveElementalMooseVariables(), SubProblem::hasActiveElementalMooseVariables(), SubProblem::setActiveElementalMooseVariables(), and SubProblem::SubProblem().

◆ _has_active_material_properties

std::vector<unsigned char> FEProblemBase::_has_active_material_properties

protected

Whether there are active material properties on each thread.

Definition at line 3493 of file FEProblemBase.h.

Referenced by clearActiveMaterialProperties(), FEProblemBase(), hasActiveMaterialProperties(), and setActiveMaterialProperties().

◆ _has_constraints

bool FEProblemBase::_has_constraints

protected

Whether or not this system has any Constraints.

Definition at line 3452 of file FEProblemBase.h.

Referenced by addConstraint(), NonlinearSystemBase::computeJacobianInternal(), and NonlinearSystemBase::computeResidualInternal().

◆ _has_dampers

bool FEProblemBase::_has_dampers

protected

Whether or not this system has any Dampers associated with it.

Definition at line 3449 of file FEProblemBase.h.

Referenced by addDamper(), computeDamping(), computePostCheck(), and hasDampers().

◆ _has_exception

bool FEProblemBase::_has_exception

protected

Whether or not an exception has occurred.

Definition at line 3543 of file FEProblemBase.h.

Referenced by checkExceptionAndStopSolve(), hasException(), and setException().

◆ _has_initialized_stateful

bool FEProblemBase::_has_initialized_stateful

protected

Whether nor not stateful materials have been initialized.

Definition at line 3464 of file FEProblemBase.h.

Referenced by meshChanged().

◆ _has_internal_edge_residual_objects

bool FEProblemBase::_has_internal_edge_residual_objects

private

Whether the problem has dgkernels or interface kernels.

Definition at line 3688 of file FEProblemBase.h.

Referenced by addDGKernel(), addInterfaceKernel(), and hasNeighborCoupling().

◆ _has_jacobian

bool FEProblemBase::_has_jacobian

protected

Indicates if the Jacobian was computed.

Definition at line 3470 of file FEProblemBase.h.

Referenced by computeJacobianTags(), hasJacobian(), meshChanged(), and prepare().

◆ _has_kokkos_objects

bool FEProblemBase::_has_kokkos_objects = false

private

Whether we have any Kokkos objects.

Definition at line 3754 of file FEProblemBase.h.

Referenced by hasKokkosObjects(), init(), and initElementStatefulProps().

◆ _has_kokkos_residual_objects

bool FEProblemBase::_has_kokkos_residual_objects = false

private

Whether we have any Kokkos residual objects.

Definition at line 3757 of file FEProblemBase.h.

Referenced by hasKokkosResidualObjects().

◆ _has_mortar

bool FEProblemBase::_has_mortar

private

Whether the simulation requires mortar coupling.

Definition at line 3710 of file FEProblemBase.h.

Referenced by createMortarInterface(), and hasMortarCoupling().

◆ _has_nonlocal_coupling

bool FEProblemBase::_has_nonlocal_coupling

protected

Indicates if nonlocal coupling is required/exists.

Definition at line 3487 of file FEProblemBase.h.

Referenced by addJacobian(), addJacobianBlockTags(), hasNonlocalCoupling(), prepare(), prepare(), prepareAssembly(), reinitDirac(), reinitElemPhys(), and timestepSetup().

◆ _has_time_integrator

bool FEProblemBase::_has_time_integrator

protected

Indicates whether or not this executioner has a time integrator (during setup)

Definition at line 3540 of file FEProblemBase.h.

Referenced by addTimeIntegrator(), and hasTimeIntegrator().

◆ _have_ad_objects

bool SubProblem::_have_ad_objects

protectedinherited

AD flag indicating whether any AD objects have been added.

Definition at line 1115 of file SubProblem.h.

Referenced by SubProblem::haveADObjects(), SubProblem::haveADObjects(), DisplacedProblem::haveADObjects(), and haveADObjects().

◆ _have_fv

bool FEProblemBase::_have_fv = false

private

Whether we are performing some calculations with finite volume discretizations.

Definition at line 3740 of file FEProblemBase.h.

Referenced by haveFV(), and needFV().

◆ _ics

InitialConditionWarehouse FEProblemBase::_ics

protected

Initial condition storage

Definition at line 3297 of file FEProblemBase.h.

Referenced by addInitialCondition(), and getInitialConditionWarehouse().

◆ _identify_variable_groups_in_nl

const bool FEProblemBase::_identify_variable_groups_in_nl

private

Whether to identify variable groups in nonlinear systems. This affects dof ordering.

Definition at line 3732 of file FEProblemBase.h.

Referenced by identifyVariableGroupsInNL().

◆ _ignore_zeros_in_jacobian

bool FEProblemBase::_ignore_zeros_in_jacobian

private

Whether to ignore zeros in the Jacobian, thereby leading to a reduced sparsity pattern.

Definition at line 3672 of file FEProblemBase.h.

Referenced by ignoreZerosInJacobian(), setIgnoreZerosInJacobian(), and setPreserveMatrixSparsityPattern().

◆ _immediately_print_invalid_solution

const bool& FEProblemBase::_immediately_print_invalid_solution

private

Definition at line 3682 of file FEProblemBase.h.

Referenced by immediatelyPrintInvalidSolution().

◆ _indicators

MooseObjectWarehouse<Indicator> FEProblemBase::_indicators

protected

Definition at line 3327 of file FEProblemBase.h.

Referenced by addIndicator(), computeIndicators(), customSetup(), getIndicatorWarehouse(), timestepSetup(), and updateActiveObjects().

◆ _initialized

bool FEProblemBase::_initialized

protected

Definition at line 3163 of file FEProblemBase.h.

Referenced by init(), initialized(), and updateMortarMesh().

◆ _input_file_saved

bool FEProblemBase::_input_file_saved

protected

whether input file has been written

Definition at line 3446 of file FEProblemBase.h.

◆ _interface_mat_side_cache

std::vector<std::unordered_map<BoundaryID, bool> > FEProblemBase::_interface_mat_side_cache

protected

Cache for calculating materials on interface.

Definition at line 3368 of file FEProblemBase.h.

Referenced by FEProblemBase(), and needInterfaceMaterialOnSide().

◆ _interface_materials

MaterialWarehouse FEProblemBase::_interface_materials

protected

Definition at line 3316 of file FEProblemBase.h.

Referenced by addInterfaceMaterial(), getInterfaceMaterialsWarehouse(), needInterfaceMaterialOnSide(), and reinitMaterialsInterface().

◆ _internal_side_indicators

MooseObjectWarehouse<InternalSideIndicatorBase> FEProblemBase::_internal_side_indicators

protected

Definition at line 3328 of file FEProblemBase.h.

Referenced by addIndicator(), computeIndicators(), customSetup(), getInternalSideIndicatorWarehouse(), timestepSetup(), and updateActiveObjects().

◆ _is_petsc_options_inserted

bool FEProblemBase::_is_petsc_options_inserted

protected

If or not PETSc options have been added to database.

Definition at line 3573 of file FEProblemBase.h.

Referenced by FEProblemBase(), petscOptionsInserted(), solve(), and solveLinearSystem().

◆ _kernel_coverage_blocks

std::vector<SubdomainName> FEProblemBase::_kernel_coverage_blocks

protected

Definition at line 3499 of file FEProblemBase.h.

Referenced by checkProblemIntegrity(), and FEProblemBase().

◆ _kernel_coverage_check

CoverageCheckMode FEProblemBase::_kernel_coverage_check

protected

Determines whether and which subdomains are to be checked to ensure that they have an active kernel.

Definition at line 3498 of file FEProblemBase.h.

Referenced by checkProblemIntegrity(), FEProblemBase(), setKernelCoverageCheck(), and setKernelCoverageCheck().

◆ _kokkos_assembly

Moose::Kokkos::Assembly FEProblemBase::_kokkos_assembly

protected

Definition at line 3271 of file FEProblemBase.h.

Referenced by kokkosAssembly(), and kokkosAssembly().

◆ _kokkos_bnd_material_props

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::_kokkos_bnd_material_props

protected

Definition at line 3310 of file FEProblemBase.h.

Referenced by DumpObjectsProblem::addAuxVariable(), advanceState(), and getKokkosBndMaterialPropertyStorage().

◆ _kokkos_fe_systems

Moose::Kokkos::Array<Moose::Kokkos::FESystem> FEProblemBase::_kokkos_fe_systems

protected

FESystem array - sparsely populated (only slots for systems needing a Kokkos::FESystem)

Definition at line 3260 of file FEProblemBase.h.

Referenced by getKokkosFESystems(), and getKokkosFESystems().

◆ _kokkos_functions

MooseObjectWarehouse<Moose::FunctionBase> FEProblemBase::_kokkos_functions

protected

Definition at line 3283 of file FEProblemBase.h.

Referenced by computeJacobianTags(), computeLinearSystemTags(), computeResidualAndJacobian(), computeResidualTags(), customSetup(), getKokkosFunction(), and timestepSetup().

◆ _kokkos_material_props

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::_kokkos_material_props

protected

Definition at line 3309 of file FEProblemBase.h.

Referenced by DumpObjectsProblem::addAuxVariable(), advanceState(), and getKokkosMaterialPropertyStorage().

◆ _kokkos_materials

MaterialWarehouse FEProblemBase::_kokkos_materials

protected

Definition at line 3321 of file FEProblemBase.h.

Referenced by getKokkosMaterialsWarehouse(), and updateActiveObjects().

◆ _kokkos_mesh_initialization_hooks

std::vector<std::function<void()> > FEProblemBase::_kokkos_mesh_initialization_hooks

private

Container holding hooks for functions that need to be called after Kokkos mesh initialization.

Definition at line 3760 of file FEProblemBase.h.

Referenced by addKokkosMeshInitializationHook().

◆ _kokkos_neighbor_material_props

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::_kokkos_neighbor_material_props

protected

Definition at line 3311 of file FEProblemBase.h.

Referenced by DumpObjectsProblem::addAuxVariable(), advanceState(), and getKokkosNeighborMaterialPropertyStorage().

◆ _kokkos_systems

Moose::Kokkos::Array<Moose::Kokkos::System> FEProblemBase::_kokkos_systems

protected

System array - sparsely populated (only slots for systems needing a Kokkos::System)

Definition at line 3258 of file FEProblemBase.h.

Referenced by getKokkosSystems(), and getKokkosSystems().

◆ _line_search

std::shared_ptr<LineSearch> FEProblemBase::_line_search

protected

Definition at line 3575 of file FEProblemBase.h.

Referenced by FEProblem::addLineSearch(), customSetup(), getLineSearch(), lineSearch(), and timestepSetup().

◆ _linear_convergence_names

std::optional<std::vector<ConvergenceName> > FEProblemBase::_linear_convergence_names

protected

Linear system(s) convergence name(s) (if any)

Definition at line 3168 of file FEProblemBase.h.

Referenced by getLinearConvergenceNames(), hasLinearConvergenceObjects(), and setLinearConvergenceNames().

◆ _linear_matrix_tags

std::set<TagID> FEProblemBase::_linear_matrix_tags

protected

Temporary storage for filtered matrix tags for linear systems.

Definition at line 3182 of file FEProblemBase.h.

Referenced by computeLinearSystemSys().

◆ _linear_sys_name_to_num

std::map<LinearSystemName, unsigned int> FEProblemBase::_linear_sys_name_to_num

protected

Map from linear system name to number.

Definition at line 3212 of file FEProblemBase.h.

Referenced by FEProblemBase(), and linearSysNum().

◆ _linear_sys_names

const std::vector<LinearSystemName> FEProblemBase::_linear_sys_names

protected

The linear system names.

Definition at line 3203 of file FEProblemBase.h.

Referenced by DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), FEProblem::FEProblem(), FEProblemBase(), and getLinearSystemNames().

◆ _linear_systems

std::vector<std::shared_ptr<LinearSystem> > FEProblemBase::_linear_systems

protected

The vector of linear systems.

Definition at line 3209 of file FEProblemBase.h.

Referenced by computeResidualL2Norm(), currentLinearSysNum(), DumpObjectsProblem::DumpObjectsProblem(), FEProblem::FEProblem(), getLinearSystem(), getLinearSystem(), setCurrentLinearSystem(), systemBaseLinear(), and systemBaseLinear().

◆ _linear_vector_tags

std::set<TagID> FEProblemBase::_linear_vector_tags

protected

Temporary storage for filtered vector tags for linear systems.

Definition at line 3179 of file FEProblemBase.h.

Referenced by computeLinearSystemSys().

◆ _map_block_material_props

std::map<SubdomainID, std::set<std::string> > SubProblem::_map_block_material_props

protectedinherited

Map of material properties (block_id -> list of properties)

Definition at line 1053 of file SubProblem.h.

Referenced by SubProblem::checkBlockMatProps(), SubProblem::getMaterialPropertyBlocks(), SubProblem::hasBlockMaterialProperty(), and SubProblem::storeSubdomainMatPropName().

◆ _map_block_material_props_check

std::map<SubdomainID, std::multimap<std::string, std::string> > SubProblem::_map_block_material_props_check

protectedinherited

Data structures of the requested material properties.

We store them in a map from boundary/block id to multimap. Each of the multimaps is a list of requestor object names to material property names.

Definition at line 1071 of file SubProblem.h.

Referenced by SubProblem::checkBlockMatProps(), and SubProblem::storeSubdomainDelayedCheckMatProp().

◆ _map_boundary_material_props

std::map<BoundaryID, std::set<std::string> > SubProblem::_map_boundary_material_props

protectedinherited

Map for boundary material properties (boundary_id -> list of properties)

Definition at line 1056 of file SubProblem.h.

Referenced by SubProblem::checkBoundaryMatProps(), SubProblem::getMaterialPropertyBoundaryIDs(), SubProblem::hasBoundaryMaterialProperty(), and SubProblem::storeBoundaryMatPropName().

◆ _map_boundary_material_props_check

std::map<BoundaryID, std::multimap<std::string, std::string> > SubProblem::_map_boundary_material_props_check

protectedinherited

Definition at line 1072 of file SubProblem.h.

Referenced by SubProblem::checkBoundaryMatProps(), and SubProblem::storeBoundaryDelayedCheckMatProp().

◆ _markers

MooseObjectWarehouse<Marker> FEProblemBase::_markers

protected

Definition at line 3332 of file FEProblemBase.h.

Referenced by addMarker(), computeMarkers(), customSetup(), getMarkerWarehouse(), timestepSetup(), and updateActiveObjects().

◆ _material_coverage_blocks

std::vector<SubdomainName> FEProblemBase::_material_coverage_blocks

protected

Definition at line 3514 of file FEProblemBase.h.

Referenced by checkProblemIntegrity(), and FEProblemBase().

◆ _material_coverage_check

CoverageCheckMode FEProblemBase::_material_coverage_check

protected

Determines whether and which subdomains are to be checked to ensure that they have an active material.

Definition at line 3513 of file FEProblemBase.h.

Referenced by checkProblemIntegrity(), FEProblemBase(), setMaterialCoverageCheck(), and setMaterialCoverageCheck().

◆ _material_dependency_check

const bool FEProblemBase::_material_dependency_check

protected

Determines whether a check to verify material dependencies on every subdomain.

Definition at line 3523 of file FEProblemBase.h.

Referenced by checkProblemIntegrity().

◆ _material_prop_registry

MaterialPropertyRegistry FEProblemBase::_material_prop_registry

protected

Definition at line 3303 of file FEProblemBase.h.

Referenced by checkDependMaterialsHelper(), and getMaterialPropertyRegistry().

◆ _material_property_requested

std::set<std::string> SubProblem::_material_property_requested

protectedinherited

set containing all material property names that have been requested by getMaterialProperty*

Definition at line 1063 of file SubProblem.h.

Referenced by SubProblem::isMatPropRequested(), and SubProblem::markMatPropRequested().

◆ _material_props

MaterialPropertyStorage& FEProblemBase::_material_props

protected

Definition at line 3304 of file FEProblemBase.h.

Referenced by addAnyRedistributers(), advanceState(), checkProblemIntegrity(), getMaterialData(), getMaterialPropertyStorage(), getMaterialPropertyStorageConsumers(), initElementStatefulProps(), initXFEM(), meshChanged(), reinitMaterials(), and swapBackMaterials().

◆ _materials

MaterialWarehouse FEProblemBase::_materials

protected

Definition at line 3315 of file FEProblemBase.h.

Referenced by addFunctorMaterial(), addMaterial(), getFVMatsAndDependencies(), getRegularMaterialsWarehouse(), prepareMaterials(), reinitMaterials(), reinitMaterialsBoundary(), reinitMaterialsFace(), reinitMaterialsFaceOnBoundary(), reinitMaterialsNeighbor(), and updateActiveObjects().

◆ _matrix_tag_id_to_tag_name

std::map<TagID, TagName> SubProblem::_matrix_tag_id_to_tag_name

protectedinherited

Reverse map.

Definition at line 1045 of file SubProblem.h.

Referenced by SubProblem::addMatrixTag(), SubProblem::matrixTagExists(), and SubProblem::matrixTagName().

◆ _matrix_tag_name_to_tag_id

std::map<TagName, TagID> SubProblem::_matrix_tag_name_to_tag_id

protectedinherited

The currently declared tags.

Definition at line 1042 of file SubProblem.h.

Referenced by SubProblem::addMatrixTag(), SubProblem::getMatrixTagID(), SubProblem::getMatrixTags(), SubProblem::matrixTagExists(), and SubProblem::numMatrixTags().

◆ _max_qps

unsigned int FEProblemBase::_max_qps

protected

Maximum number of quadrature points used in the problem.

Definition at line 3534 of file FEProblemBase.h.

Referenced by getMaxQps(), reinitDirac(), and updateMaxQps().

◆ _max_scalar_order

libMesh::Order FEProblemBase::_max_scalar_order

protected

Maximum scalar variable order.

Definition at line 3537 of file FEProblemBase.h.

Referenced by addAuxScalarVariable(), and getMaxScalarOrder().

◆ _mesh

MooseMesh& FEProblemBase::_mesh

protected

Definition at line 3115 of file FEProblemBase.h.

Referenced by adaptMesh(), addAnyRedistributers(), addAuxVariable(), addGhostedBoundary(), addGhostedElem(), addVariable(), checkCoordinateSystems(), checkDependMaterialsHelper(), checkProblemIntegrity(), checkUserObjects(), DumpObjectsProblem::dumpVariableHelper(), duplicateVariableCheck(), getCurrentAlgebraicBndNodeRange(), getCurrentAlgebraicElementRange(), getCurrentAlgebraicNodeRange(), getDiracElements(), getEvaluableElementRange(), getNonlinearEvaluableElementRange(), ghostGhostedBoundaries(), init(), initialAdaptMesh(), initXFEM(), mesh(), MFEMProblem::mesh(), mesh(), meshChanged(), possiblyRebuildGeomSearchPatches(), prepareMaterials(), projectSolution(), reinitElemNeighborAndLowerD(), reinitElemPhys(), reinitNeighborPhys(), reinitNeighborPhys(), setAxisymmetricCoordAxis(), setCoordSystem(), timestepSetup(), and uniformRefine().

◆ _mesh_divisions

MooseObjectWarehouse<MeshDivision> FEProblemBase::_mesh_divisions

protected

Warehouse to store mesh divisions NOTE: this could probably be moved to the MooseMesh instead of the Problem Time (and people's uses) will tell where this fits best.

Definition at line 3277 of file FEProblemBase.h.

Referenced by addMeshDivision(), and getMeshDivision().

◆ _metaname

const RestartableDataMapName Restartable::_metaname

privateinherited

Restartable metadata name.

Definition at line 247 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

◆ _mortar_data

std::unique_ptr<MortarInterfaceWarehouse> FEProblemBase::_mortar_data

protected

Definition at line 3436 of file FEProblemBase.h.

Referenced by checkProblemIntegrity(), computeJacobianTags(), computeResidualAndJacobian(), computeResidualTags(), createMortarInterface(), getMortarInterface(), getMortarInterface(), getMortarInterfaces(), init(), meshChanged(), mortarData(), mortarData(), reinitBecauseOfGhostingOrNewGeomObjects(), and updateMortarMesh().

◆ _multi_apps

ExecuteMooseObjectWarehouse<MultiApp> FEProblemBase::_multi_apps

protected

MultiApp Warehouse.

Definition at line 3338 of file FEProblemBase.h.

Referenced by addMultiApp(), backupMultiApps(), execMultiApps(), execMultiAppTransfers(), finalizeMultiApps(), finishMultiAppStep(), getMultiApp(), getMultiAppWarehouse(), hasMultiApp(), hasMultiApps(), hasMultiApps(), incrementMultiAppTStep(), parentOutputPositionChanged(), partitionConcurrentMultiApps(), postExecute(), restoreMultiApps(), and updateActiveObjects().

◆ _multiapp_fixed_point_convergence_name

std::optional<ConvergenceName> FEProblemBase::_multiapp_fixed_point_convergence_name

protected

MultiApp fixed point convergence name.

Definition at line 3170 of file FEProblemBase.h.

Referenced by getMultiAppFixedPointConvergenceName(), hasSetMultiAppFixedPointConvergenceName(), and setMultiAppFixedPointConvergenceName().

◆ _name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

◆ _need_to_add_default_multiapp_fixed_point_convergence

bool FEProblemBase::_need_to_add_default_multiapp_fixed_point_convergence

protected

Flag that the problem needs to add the default fixed point convergence.

Definition at line 3198 of file FEProblemBase.h.

Referenced by needToAddDefaultMultiAppFixedPointConvergence(), and setNeedToAddDefaultMultiAppFixedPointConvergence().

◆ _need_to_add_default_nonlinear_convergence

bool FEProblemBase::_need_to_add_default_nonlinear_convergence

protected

Flag that the problem needs to add the default nonlinear convergence.

Definition at line 3196 of file FEProblemBase.h.

Referenced by needToAddDefaultNonlinearConvergence(), and setNeedToAddDefaultNonlinearConvergence().

◆ _need_to_add_default_steady_state_convergence

bool FEProblemBase::_need_to_add_default_steady_state_convergence

protected

Flag that the problem needs to add the default steady convergence.

Definition at line 3200 of file FEProblemBase.h.

Referenced by needToAddDefaultSteadyStateConvergence(), and setNeedToAddDefaultSteadyStateConvergence().

◆ _needs_old_newton_iter

bool FEProblemBase::_needs_old_newton_iter

protected

Indicates that we need to compute variable values for previous Newton iteration.

Definition at line 3473 of file FEProblemBase.h.

◆ _neighbor_material_props

MaterialPropertyStorage& FEProblemBase::_neighbor_material_props

protected

Definition at line 3306 of file FEProblemBase.h.

Referenced by addAnyRedistributers(), advanceState(), checkProblemIntegrity(), getMaterialData(), getMaterialPropertyStorageConsumers(), getNeighborMaterialPropertyStorage(), initElementStatefulProps(), meshChanged(), reinitMaterialsNeighbor(), and swapBackMaterialsNeighbor().

◆ _nl

std::vector<std::shared_ptr<NonlinearSystemBase> > FEProblemBase::_nl

protected

The nonlinear systems.

Definition at line 3227 of file FEProblemBase.h.

Referenced by addBoundaryCondition(), addConstraint(), addDamper(), addDGKernel(), addDiracKernel(), addHDGKernel(), addInterfaceKernel(), addKernel(), addNodalKernel(), addPredictor(), addScalarKernel(), addTimeIntegrator(), bumpAllQRuleOrder(), bumpVolumeQRuleOrder(), checkNonlocalCoupling(), checkProblemIntegrity(), computeResidualL2Norm(), computingPreSMOResidual(), currentNlSysNum(), customSetup(), DumpObjectsProblem::DumpObjectsProblem(), ExternalProblem::ExternalProblem(), finalNonlinearResidual(), getNonlinearEvaluableElementRange(), getNonlinearSystem(), getNonlinearSystemBase(), getNonlinearSystemBase(), init(), initXFEM(), jacobianSetup(), meshChanged(), needBoundaryMaterialOnSide(), needInterfaceMaterialOnSide(), needInternalNeighborSideMaterial(), nLinearIterations(), nNonlinearIterations(), onTimestepBegin(), prepare(), prepareFace(), projectInitialConditionOnCustomRange(), projectSolution(), reinitDirac(), reinitNeighbor(), reinitNeighborPhys(), reinitNeighborPhys(), reinitNode(), reinitNodeFace(), reinitScalars(), residualSetup(), setCurrentNonlinearSystem(), setNeighborSubdomainID(), setNeighborSubdomainID(), setNonlinearConvergenceNames(), setNonlocalCouplingMatrix(), setResidual(), setResidualObjectParamsAndLog(), setupDampers(), subdomainSetup(), systemBaseNonlinear(), systemBaseNonlinear(), updateActiveObjects(), and updateMeshXFEM().

◆ _nl_evaluable_local_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_nl_evaluable_local_elem_range

protected

Definition at line 3578 of file FEProblemBase.h.

Referenced by getNonlinearEvaluableElementRange(), and meshChanged().

◆ _nl_sys_name_to_num

std::map<NonlinearSystemName, unsigned int> FEProblemBase::_nl_sys_name_to_num

protected

Map from nonlinear system name to number.

Definition at line 3230 of file FEProblemBase.h.

Referenced by FEProblemBase(), and nlSysNum().

◆ _nl_sys_names

const std::vector<NonlinearSystemName> FEProblemBase::_nl_sys_names

protected

The nonlinear system names.

Definition at line 3221 of file FEProblemBase.h.

Referenced by DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), FEProblem::FEProblem(), FEProblemBase(), and getNonlinearSystemNames().

◆ _nonlinear_convergence_names

std::optional<std::vector<ConvergenceName> > FEProblemBase::_nonlinear_convergence_names

protected

Nonlinear system(s) convergence name(s)

Definition at line 3166 of file FEProblemBase.h.

Referenced by getNonlinearConvergenceNames(), and setNonlinearConvergenceNames().

◆ _nonlocal_cm

std::vector<libMesh::CouplingMatrix> FEProblemBase::_nonlocal_cm

private

nonlocal coupling matrix

Definition at line 3747 of file FEProblemBase.h.

Referenced by addJacobianBlockTags(), FEProblemBase(), nonlocalCouplingMatrix(), prepare(), and setNonlocalCouplingMatrix().

◆ _nonlocal_integrated_bcs

MooseObjectWarehouse<IntegratedBCBase> FEProblemBase::_nonlocal_integrated_bcs

protected

nonlocal integrated_bcs

Definition at line 3293 of file FEProblemBase.h.

Referenced by checkNonlocalCoupling(), setNonlocalCouplingMatrix(), and timestepSetup().

◆ _nonlocal_kernels

MooseObjectWarehouse<KernelBase> FEProblemBase::_nonlocal_kernels

protected

nonlocal kernels

Definition at line 3290 of file FEProblemBase.h.

Referenced by checkNonlocalCoupling(), setNonlocalCouplingMatrix(), and timestepSetup().

◆ _not_zeroed_tagged_vectors

std::unordered_set<TagID> SubProblem::_not_zeroed_tagged_vectors

protectedinherited

the list of vector tags that will not be zeroed when all other tags are

Definition at line 1118 of file SubProblem.h.

Referenced by SubProblem::addNotZeroedVectorTag(), restoreSolutions(), and SubProblem::vectorTagNotZeroed().

◆ _notify_when_mesh_changes

std::vector<MeshChangedInterface *> FEProblemBase::_notify_when_mesh_changes

protected

Objects to be notified when the mesh changes.

Definition at line 3371 of file FEProblemBase.h.

Referenced by meshChanged(), and notifyWhenMeshChanges().

◆ _notify_when_mesh_displaces

std::vector<MeshDisplacedInterface *> FEProblemBase::_notify_when_mesh_displaces

protected

Objects to be notified when the mesh displaces.

Definition at line 3374 of file FEProblemBase.h.

Referenced by meshDisplaced(), and notifyWhenMeshDisplaces().

◆ _num_concurrent_multiapps

const unsigned int FEProblemBase::_num_concurrent_multiapps

protected

Number of concurrent applications being solved at the same time.

Definition at line 3356 of file FEProblemBase.h.

Referenced by execMultiApps(), numConcurrentMultiApps(), and partitionConcurrentMultiApps().

◆ _num_grid_steps

unsigned int FEProblemBase::_num_grid_steps

private

Number of steps in a grid sequence.

Definition at line 3713 of file FEProblemBase.h.

Referenced by addAnyRedistributers(), checkProblemIntegrity(), numGridSteps(), and timestepSetup().

◆ _num_linear_sys

const std::size_t FEProblemBase::_num_linear_sys

protected

The number of linear systems.

Definition at line 3206 of file FEProblemBase.h.

Referenced by FEProblem::FEProblem(), FEProblemBase(), numLinearSystems(), and numSolverSystems().

◆ _num_nl_sys

const std::size_t FEProblemBase::_num_nl_sys

protected

The number of nonlinear systems.

Definition at line 3224 of file FEProblemBase.h.

Referenced by ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), FEProblemBase(), isSolverSystemNonlinear(), numNonlinearSystems(), numSolverSystems(), and prepare().

◆ _parallel_barrier_messaging

bool FEProblemBase::_parallel_barrier_messaging

protected

Whether or not information about how many transfers have completed is printed.

Definition at line 3546 of file FEProblemBase.h.

Referenced by backupMultiApps(), execMultiApps(), execMultiAppTransfers(), finishMultiAppStep(), restoreMultiApps(), and setParallelBarrierMessaging().

◆ _parent

const ParallelParamObject& DataFileInterface::_parent

privateinherited

Definition at line 58 of file DataFileInterface.h.

Referenced by DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), and DataFileInterface::getDataFilePath().

◆ _pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 384 of file MooseBase.h.

Referenced by AddAuxKernelAction::act(), AddFVICAction::act(), AddICAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), EigenProblemSolve::initialSetup(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseApp::MooseApp(), MooseBase::MooseBase(), MultiSystemSolveObject::MultiSystemSolveObject(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), MooseBase::queryParam(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

◆ _pbblf_functors

std::vector<std::map<std::string, std::unique_ptr<Moose::FunctorAbstract> > > SubProblem::_pbblf_functors

privateinherited

Container to hold PiecewiseByBlockLambdaFunctors.

Definition at line 1148 of file SubProblem.h.

Referenced by SubProblem::addPiecewiseByBlockLambdaFunctor(), SubProblem::customSetup(), SubProblem::jacobianSetup(), SubProblem::residualSetup(), SubProblem::SubProblem(), and SubProblem::timestepSetup().

◆ _petsc_option_data_base

PetscOptions FEProblemBase::_petsc_option_data_base

protected

Definition at line 3569 of file FEProblemBase.h.

Referenced by FEProblemBase(), petscOptionsDatabase(), solve(), EigenProblem::solve(), solveLinearSystem(), and ~FEProblemBase().

◆ _petsc_options

Moose::PetscSupport::PetscOptions FEProblemBase::_petsc_options

protected

PETSc option storage.

Definition at line 3567 of file FEProblemBase.h.

Referenced by getPetscOptions(), solve(), and solveLinearSystem().

◆ _pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

◆ _phi_zero

std::vector<VariablePhiValue> FEProblemBase::_phi_zero

Definition at line 2604 of file FEProblemBase.h.

Referenced by FEProblemBase(), and ~FEProblemBase().

◆ _point_zero

std::vector<Point> FEProblemBase::_point_zero

Definition at line 2612 of file FEProblemBase.h.

Referenced by FEProblemBase().

◆ _prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

◆ _preserve_matrix_sparsity_pattern

bool FEProblemBase::_preserve_matrix_sparsity_pattern

private

Whether to preserve the system matrix / Jacobian sparsity pattern, using 0-valued entries usually.

Definition at line 3674 of file FEProblemBase.h.

Referenced by preserveMatrixSparsityPattern(), and setPreserveMatrixSparsityPattern().

◆ _previous_multiapp_fp_aux_solution_required

bool FEProblemBase::_previous_multiapp_fp_aux_solution_required

protected

Indicates we need to save the previous multiapp fixed-point iteration auxiliary variable values.

Definition at line 3480 of file FEProblemBase.h.

Referenced by needsPreviousMultiAppFixedPointIterationAuxiliary(), and needsPreviousMultiAppFixedPointIterationAuxiliary().

◆ _previous_multiapp_fp_nl_solution_required

std::vector<bool> FEProblemBase::_previous_multiapp_fp_nl_solution_required

protected

Indicates we need to save the previous multiapp fixed-point iteration solver variable values.

Definition at line 3478 of file FEProblemBase.h.

Referenced by needsPreviousMultiAppFixedPointIterationSolution(), and needsPreviousMultiAppFixedPointIterationSolution().

◆ _previous_multisystem_fp_aux_solution_required

bool FEProblemBase::_previous_multisystem_fp_aux_solution_required

protected

Indicates we need to save the previous multi-system fixed-point iteration auxiliary variable values.

Definition at line 3484 of file FEProblemBase.h.

Referenced by needsPreviousMultiSystemFixedPointIterationAuxiliary(), and needsPreviousMultiSystemFixedPointIterationAuxiliary().

◆ _previous_multisystem_fp_nl_solution_required

std::vector<bool> FEProblemBase::_previous_multisystem_fp_nl_solution_required

protected

Indicates we need to save the previous multi-system fixed-point iteration solver variable values.

Definition at line 3482 of file FEProblemBase.h.

Referenced by needsPreviousMultiSystemFixedPointIterationSolution(), and needsPreviousMultiSystemFixedPointIterationSolution().

◆ _previous_nl_solution_required

bool FEProblemBase::_previous_nl_solution_required

protected

Indicates we need to save the previous NL iteration variable values.

Definition at line 3476 of file FEProblemBase.h.

Referenced by createTagSolutions().

◆ _print_execution_on

ExecFlagEnum FEProblemBase::_print_execution_on

private

When to print the execution of loops.

Definition at line 3729 of file FEProblemBase.h.

Referenced by setExecutionPrinting(), and shouldPrintExecution().

◆ _random_data_objects

std::map<std::string, std::unique_ptr<RandomData> > FEProblemBase::_random_data_objects

protected

A map of objects that consume random numbers.

Definition at line 3359 of file FEProblemBase.h.

Referenced by computeJacobianTags(), computeLinearSystemTags(), computeResidualAndJacobian(), computeResidualTags(), registerRandomInterface(), and timestepSetup().

◆ _real_zero

std::vector<Real> FEProblemBase::_real_zero

Convenience zeros.

Definition at line 2601 of file FEProblemBase.h.

Referenced by FEProblemBase().

◆ _regard_general_exceptions_as_errors

const bool FEProblemBase::_regard_general_exceptions_as_errors

private

If we catch an exception during residual/Jacobian evaluaton for which we don't have specific handling, immediately error instead of allowing the time step to be cut.

Definition at line 3744 of file FEProblemBase.h.

Referenced by handleException().

◆ _reinit_displaced_elem

bool FEProblemBase::_reinit_displaced_elem

protected

Whether to call DisplacedProblem::reinitElem when this->reinitElem is called.

Definition at line 3439 of file FEProblemBase.h.

Referenced by addDiracKernel(), addFVKernel(), addHDGKernel(), addIndicator(), addKernel(), addMarker(), addMaterialHelper(), addMultiApp(), addNodalKernel(), addTransfer(), addUserObject(), prepare(), prepare(), prepareAssembly(), prepareFace(), reinitDirac(), reinitElem(), reinitNode(), reinitScalars(), setAuxKernelParamsAndLog(), setCurrentSubdomainID(), setNeighborSubdomainID(), and setNeighborSubdomainID().

◆ _reinit_displaced_face

bool FEProblemBase::_reinit_displaced_face

protected

Whether to call DisplacedProblem::reinitElemFace when this->reinitElemFace is called.

Definition at line 3441 of file FEProblemBase.h.

Referenced by addBoundaryCondition(), addConstraint(), addMaterialHelper(), addUserObject(), prepare(), prepare(), prepareAssembly(), prepareAssemblyNeighbor(), prepareFace(), reinitElemFace(), reinitElemNeighborAndLowerD(), reinitNodeFace(), setAuxKernelParamsAndLog(), setCurrentSubdomainID(), setNeighborSubdomainID(), and setNeighborSubdomainID().

◆ _reinit_displaced_neighbor

bool FEProblemBase::_reinit_displaced_neighbor

protected

Whether to call DisplacedProblem::reinitNeighbor when this->reinitNeighbor is called.

Definition at line 3443 of file FEProblemBase.h.

Referenced by addDGKernel(), addInterfaceKernel(), addMaterialHelper(), addUserObject(), prepare(), prepareAssembly(), prepareAssemblyNeighbor(), reinitElemNeighborAndLowerD(), reinitNeighbor(), setCurrentSubdomainID(), setNeighborSubdomainID(), and setNeighborSubdomainID().

◆ _reporter_data

ReporterData FEProblemBase::_reporter_data

protected

Definition at line 3335 of file FEProblemBase.h.

Referenced by advanceState(), checkDuplicatePostprocessorVariableNames(), MFEMProblem::executeMFEMObjects(), getPostprocessorValueByName(), getReporterData(), getReporterData(), getVectorPostprocessorValueByName(), hasPostprocessorValueByName(), joinAndFinalize(), restoreSolutions(), setPostprocessorValueByName(), and setVectorPostprocessorValueByName().

◆ _req

Restartable::ManagedValue<RestartableEquationSystems> FEProblemBase::_req

private

The EquationSystems object, wrapped for restart.

Definition at line 3119 of file FEProblemBase.h.

Referenced by es(), and getRestartableEquationSystems().

◆ _requires_nonlocal_coupling

bool FEProblemBase::_requires_nonlocal_coupling

private

nonlocal coupling requirement flag

Definition at line 3750 of file FEProblemBase.h.

Referenced by checkNonlocalCoupling(), checkNonlocalCouplingRequirement(), and timestepSetup().

◆ _restartable_app

MooseApp& Restartable::_restartable_app

protectedinherited

Reference to the application.

Definition at line 234 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp(), and Restartable::registerRestartableNameWithFilterOnApp().

◆ _restartable_name

std::string Restartable::_restartable_name

privateinherited

The name of the object.

Definition at line 250 of file Restartable.h.

Referenced by Restartable::declareRestartableDataWithObjectNameWithContext(), and Restartable::restartableName().

◆ _restartable_read_only

const bool Restartable::_restartable_read_only

protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 243 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

◆ _restartable_system_name

const std::string Restartable::_restartable_system_name

protectedinherited

The system name this object is in.

Definition at line 237 of file Restartable.h.

Referenced by Restartable::restartableName().

◆ _restartable_tid

const THREAD_ID Restartable::_restartable_tid

protectedinherited

The thread ID for this object.

Definition at line 240 of file Restartable.h.

Referenced by Restartable::declareRestartableDataHelper().

◆ _restore_original_nonzero_pattern

const bool FEProblemBase::_restore_original_nonzero_pattern

private

Whether we should restore the original nonzero pattern for every Jacobian evaluation.

This option is useful if the sparsity pattern is constantly changing and you are using hash table assembly or if you wish to continually restore the matrix to the originally preallocated sparsity pattern computed by relationship managers.

Definition at line 3670 of file FEProblemBase.h.

Referenced by computeJacobianTags(), and restoreOriginalNonzeroPattern().

◆ _root_alg_gf_to_sys_clones

std::unordered_map<libMesh::GhostingFunctor *, std::vector<std::shared_ptr<libMesh::GhostingFunctor> > > SubProblem::_root_alg_gf_to_sys_clones

privateinherited

A map from a root algebraic ghosting functor, e.g.

the ghosting functor passed into removeAlgebraicGhostingFunctor, to its clones in other systems, e.g. systems other than system 0

Definition at line 1196 of file SubProblem.h.

Referenced by SubProblem::cloneAlgebraicGhostingFunctor(), and SubProblem::removeAlgebraicGhostingFunctor().

◆ _root_coupling_gf_to_sys_clones

std::unordered_map<libMesh::GhostingFunctor *, std::vector<std::shared_ptr<libMesh::GhostingFunctor> > > SubProblem::_root_coupling_gf_to_sys_clones

privateinherited

A map from a root coupling ghosting functor, e.g.

the ghosting functor passed into removeCouplingGhostingFunctor, to its clones in other systems, e.g. systems other than system 0

Definition at line 1203 of file SubProblem.h.

Referenced by SubProblem::cloneCouplingGhostingFunctor(), and SubProblem::removeCouplingGhostingFunctor().

◆ _safe_access_tagged_matrices

bool SubProblem::_safe_access_tagged_matrices

protectedinherited

Is it safe to retrieve data from tagged matrices.

Definition at line 1109 of file SubProblem.h.

Referenced by computeJacobianTags(), computeLinearSystemTags(), computeResidualAndJacobian(), resetState(), and SubProblem::safeAccessTaggedMatrices().

◆ _safe_access_tagged_vectors

bool SubProblem::_safe_access_tagged_vectors

protectedinherited

Is it safe to retrieve data from tagged vectors.

Definition at line 1112 of file SubProblem.h.

Referenced by computeLinearSystemTags(), computeResidualAndJacobian(), computeResidualTags(), resetState(), and SubProblem::safeAccessTaggedVectors().

◆ _scalar_ics

ScalarInitialConditionWarehouse FEProblemBase::_scalar_ics

protected

Definition at line 3299 of file FEProblemBase.h.

Referenced by addInitialCondition(), projectInitialConditionOnCustomRange(), and projectSolution().

◆ _scalar_zero

std::vector<VariableValue> FEProblemBase::_scalar_zero

Definition at line 2602 of file FEProblemBase.h.

Referenced by FEProblemBase(), reinitDirac(), updateMaxQps(), and ~FEProblemBase().

◆ _second_phi_zero

std::vector<VariablePhiSecond> FEProblemBase::_second_phi_zero

Definition at line 2611 of file FEProblemBase.h.

Referenced by FEProblemBase(), and ~FEProblemBase().

◆ _second_zero

std::vector<VariableSecond> FEProblemBase::_second_zero

Definition at line 2609 of file FEProblemBase.h.

Referenced by FEProblemBase(), reinitDirac(), updateMaxQps(), and ~FEProblemBase().

◆ _show_chain_control_data

bool SubProblem::_show_chain_control_data

privateinherited

Whether to output a list of all the chain control data.

Definition at line 1168 of file SubProblem.h.

Referenced by SubProblem::initialSetup(), SubProblem::setChainControlDataOutput(), and SubProblem::timestepSetup().

◆ _show_functors

bool SubProblem::_show_functors

privateinherited

Whether to output a list of the functors used and requested (currently only at initialSetup)

Definition at line 1165 of file SubProblem.h.

Referenced by SubProblem::initialSetup(), and SubProblem::setFunctorOutput().

◆ _show_invalid_solution_console

const bool FEProblemBase::_show_invalid_solution_console

private

Definition at line 3681 of file FEProblemBase.h.

Referenced by showInvalidSolutionConsole().

◆ _si_moose_base

const MooseBase& SolutionInvalidInterface::_si_moose_base

privateinherited

The MooseBase that owns this interface.

Definition at line 111 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal(), SolutionInvalidInterface::mooseDeprecated(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), SolutionInvalidInterface::paramWarning(), and SolutionInvalidInterface::registerInvalidSolutionInternal().

◆ _si_problem

const FEProblemBase* SolutionInvalidInterface::_si_problem

privateinherited

A pointer to FEProblem base.

Definition at line 114 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

◆ _side_uo_interface_mat_prop_integrity_check

const bool FEProblemBase::_side_uo_interface_mat_prop_integrity_check

protected

Whether to check that side user objects do not consume interface material properties.

Definition at line 3510 of file FEProblemBase.h.

Referenced by sideUOInterfaceMatPropIntegrityCheck().

◆ _skip_exception_check

bool FEProblemBase::_skip_exception_check

protected

If or not skip 'exception and stop solve'.

Definition at line 3458 of file FEProblemBase.h.

Referenced by checkExceptionAndStopSolve(), initialSetup(), and skipExceptionCheck().

◆ _skip_nl_system_check

const bool FEProblemBase::_skip_nl_system_check

private

Definition at line 3678 of file FEProblemBase.h.

Referenced by checkProblemIntegrity(), and init().

◆ _snesmf_reuse_base

bool FEProblemBase::_snesmf_reuse_base

protected

If or not to resuse the base vector for matrix-free calculation.

Definition at line 3455 of file FEProblemBase.h.

Referenced by setSNESMFReuseBase(), and useSNESMFReuseBase().

◆ _snesmf_reuse_base_set_by_user

bool FEProblemBase::_snesmf_reuse_base_set_by_user

protected

If or not _snesmf_reuse_base is set by user.

Definition at line 3461 of file FEProblemBase.h.

Referenced by isSNESMFReuseBaseSetbyUser(), and setSNESMFReuseBase().

◆ _solve

const bool& FEProblemBase::_solve

protected

Whether or not to actually solve the nonlinear system.

Definition at line 3185 of file FEProblemBase.h.

Referenced by checkProblemIntegrity(), FEProblemBase(), init(), shouldSolve(), solve(), EigenProblem::solve(), solveLinearSystem(), EigenProblem::solverSystemConverged(), and solverSystemConverged().

◆ _solver_params

std::vector<SolverParams> FEProblemBase::_solver_params

protected

Definition at line 3495 of file FEProblemBase.h.

Referenced by FEProblemBase(), solve(), solveLinearSystem(), and solverParams().

◆ _solver_sys_name_to_num

std::map<SolverSystemName, unsigned int> FEProblemBase::_solver_sys_name_to_num

protected

Map connecting solver system names with their respective systems.

Definition at line 3245 of file FEProblemBase.h.

Referenced by FEProblemBase(), and solverSysNum().

◆ _solver_sys_names

std::vector<SolverSystemName> FEProblemBase::_solver_sys_names

protected

The union of nonlinear and linear system names.

Definition at line 3248 of file FEProblemBase.h.

Referenced by FEProblemBase(), getSolverSystemNames(), getSystemBase(), Moose::PetscSupport::setSinglePetscOption(), and solverSysNum().

◆ _solver_systems

std::vector<std::shared_ptr<SolverSystem> > FEProblemBase::_solver_systems

protected

Combined container to base pointer of every solver system.

Definition at line 3239 of file FEProblemBase.h.

Referenced by addObjectParamsHelper(), addTimeIntegrator(), addVariable(), advanceState(), computeSystems(), copySolutionsBackwards(), createQRules(), createTagMatrices(), createTagSolutions(), createTagVectors(), determineSolverSystem(), DumpObjectsProblem::DumpObjectsProblem(), duplicateVariableCheck(), EigenProblem::EigenProblem(), ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), getActualFieldVariable(), getArrayVariable(), getScalarVariable(), getSolverSystem(), getSolverSystem(), getStandardVariable(), getSystem(), getSystemBase(), getSystemBase(), getVariable(), getVariableNames(), getVectorVariable(), hasScalarVariable(), hasSolutionState(), hasSolverVariable(), hasVariable(), FEProblem::init(), init(), initialSetup(), meshChanged(), needSolutionState(), outputStep(), prepare(), projectSolution(), reinitElem(), reinitElemFace(), reinitElemPhys(), restoreOldSolutions(), restoreSolutions(), saveOldSolutions(), setAuxKernelParamsAndLog(), setCurrentSubdomainID(), Moose::PetscSupport::setSinglePetscOption(), setVariableAllDoFMap(), skipNextForwardSolutionCopyToOld(), solverSystemConverged(), systemBaseSolver(), systemBaseSolver(), systemNumForVariable(), and timestepSetup().

◆ _solver_var_to_sys_num

std::map<SolverVariableName, unsigned int> FEProblemBase::_solver_var_to_sys_num

protected

Map connecting variable names with their respective solver systems.

Definition at line 3242 of file FEProblemBase.h.

Referenced by addVariable(), and determineSolverSystem().

◆ _started_initial_setup

bool FEProblemBase::_started_initial_setup

private

At or beyond initialSteup stage.

Definition at line 3685 of file FEProblemBase.h.

Referenced by initialSetup(), and startedInitialSetup().

◆ _steady_state_convergence_name

std::optional<ConvergenceName> FEProblemBase::_steady_state_convergence_name

protected

Steady-state detection convergence name.

Definition at line 3172 of file FEProblemBase.h.

Referenced by getSteadyStateConvergenceName(), hasSetSteadyStateConvergenceName(), and setSteadyStateConvergenceName().

◆ _subspace_dim

std::map<std::string, unsigned int> FEProblemBase::_subspace_dim

protected

Dimension of the subspace spanned by the vectors with a given prefix.

Definition at line 3264 of file FEProblemBase.h.

Referenced by initNullSpaceVectors(), and subspaceDim().

◆ _t_step

int& FEProblemBase::_t_step

protected

Definition at line 3191 of file FEProblemBase.h.

Referenced by FEProblemBase(), timeStep(), and timestepSetup().

◆ _termination_requested

bool Problem::_termination_requested

protectedinherited

True if termination of the solve has been requested.

Definition at line 58 of file Problem.h.

Referenced by Problem::isSolveTerminationRequested(), and Problem::terminateSolve().

◆ _time

Real& FEProblemBase::_time

protected

Definition at line 3188 of file FEProblemBase.h.

Referenced by execMultiApps(), FEProblemBase(), incrementMultiAppTStep(), time(), and updateMeshXFEM().

◆ _time_old

Real& FEProblemBase::_time_old

protected

Definition at line 3189 of file FEProblemBase.h.

Referenced by FEProblemBase(), and timeOld().

◆ _time_older

Real& FEProblemBase::_time_older

protected

Definition at line 3190 of file FEProblemBase.h.

Referenced by FEProblemBase(), and timeOlder().

◆ _to_multi_app_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_to_multi_app_transfers

protected

Transfers executed just before MultiApps to transfer data to them.

Definition at line 3347 of file FEProblemBase.h.

Referenced by addTransfer(), execMultiAppTransfers(), getMultiAppTransferWarehouse(), getTransfers(), getTransfers(), and updateActiveObjects().

◆ _transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_transfers

protected

Normal Transfers.

Definition at line 3344 of file FEProblemBase.h.

Referenced by addTransfer(), and updateActiveObjects().

◆ _transient

bool FEProblemBase::_transient

protected

Definition at line 3187 of file FEProblemBase.h.

Referenced by isTransient(), and transient().

◆ _transient_multi_apps

ExecuteMooseObjectWarehouse<TransientMultiApp> FEProblemBase::_transient_multi_apps

protected

Storage for TransientMultiApps (only needed for calling 'computeDT')

Definition at line 3341 of file FEProblemBase.h.

Referenced by addMultiApp(), computeMultiAppsDT(), and updateActiveObjects().

◆ _trust_user_coupling_matrix

bool FEProblemBase::_trust_user_coupling_matrix = false

private

Whether to trust the user coupling matrix no matter what.

See https://github.com/idaholab/moose/issues/16395 for detailed background

Definition at line 3717 of file FEProblemBase.h.

Referenced by setCoupling(), and trustUserCouplingMatrix().

◆ _type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 378 of file MooseBase.h.

Referenced by FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MooseBase::MooseBase(), solverTypeString(), and MooseBase::type().

◆ _typed_vector_tags

std::vector<std::vector<VectorTag> > SubProblem::_typed_vector_tags

privateinherited

The vector tags associated with each VectorTagType This is kept separate from _vector_tags for quick access into typed vector tags in places where we don't want to build a new vector every call (like in residual evaluation)

Definition at line 1178 of file SubProblem.h.

Referenced by SubProblem::addVectorTag(), SubProblem::getVectorTags(), and SubProblem::verifyVectorTags().

◆ _u_dot_old_requested

bool FEProblemBase::_u_dot_old_requested

private

Whether old solution time derivative needs to be stored.

Definition at line 3697 of file FEProblemBase.h.

Referenced by setUDotOldRequested(), and uDotOldRequested().

◆ _u_dot_requested

bool FEProblemBase::_u_dot_requested

private

Whether solution time derivative needs to be stored.

Definition at line 3691 of file FEProblemBase.h.

Referenced by setUDotRequested(), uDotOldRequested(), and uDotRequested().

◆ _u_dotdot_old_requested

bool FEProblemBase::_u_dotdot_old_requested

private

Whether old solution second time derivative needs to be stored.

Definition at line 3700 of file FEProblemBase.h.

Referenced by setUDotDotOldRequested(), and uDotDotOldRequested().

◆ _u_dotdot_requested

bool FEProblemBase::_u_dotdot_requested

private

Whether solution second time derivative needs to be stored.

Definition at line 3694 of file FEProblemBase.h.

Referenced by setUDotDotRequested(), uDotDotOldRequested(), and uDotDotRequested().

◆ _uo_aux_state_check

const bool FEProblemBase::_uo_aux_state_check

protected

Whether or not checking the state of uo/aux evaluation.

Definition at line 3526 of file FEProblemBase.h.

Referenced by execute(), and hasUOAuxStateCheck().

◆ _uo_jacobian_moose_vars

std::vector<std::vector<const MooseVariableFEBase *> > FEProblemBase::_uo_jacobian_moose_vars

protected

Definition at line 3490 of file FEProblemBase.h.

Referenced by FEProblemBase(), getUserObjectJacobianVariables(), and meshChanged().

◆ _use_hash_table_matrix_assembly

const bool FEProblemBase::_use_hash_table_matrix_assembly

protected

Whether to assemble matrices using hash tables instead of preallocating matrix memory.

This can be a good option if the sparsity pattern changes throughout the course of the simulation

Definition at line 3594 of file FEProblemBase.h.

Referenced by EigenProblem::EigenProblem(), FEProblem::FEProblem(), and useHashTableMatrixAssembly().

◆ _using_ad_mat_props

bool FEProblemBase::_using_ad_mat_props

protected

Automatic differentiaion (AD) flag which indicates whether any consumer has requested an AD material property or whether any suppier has declared an AD material property.

Definition at line 3587 of file FEProblemBase.h.

◆ _using_default_nl

const bool FEProblemBase::_using_default_nl

protected

Boolean to check if we have the default nonlinear system.

Definition at line 3218 of file FEProblemBase.h.

◆ _var_dof_map

std::map<std::string, std::vector<dof_id_type> > SubProblem::_var_dof_map

inherited

Definition at line 685 of file SubProblem.h.

Referenced by MooseVariableBase::allDofIndices(), setNonlocalCouplingMatrix(), and setVariableAllDoFMap().

◆ _vector_curl_zero

std::vector<VectorVariableCurl> FEProblemBase::_vector_curl_zero

Definition at line 2614 of file FEProblemBase.h.

Referenced by FEProblemBase(), reinitDirac(), updateMaxQps(), and ~FEProblemBase().

◆ _vector_tags

std::vector<VectorTag> SubProblem::_vector_tags

privateinherited

The declared vector tags.

Definition at line 1171 of file SubProblem.h.

Referenced by SubProblem::addVectorTag(), SubProblem::getVectorTag(), SubProblem::getVectorTags(), SubProblem::vectorTagExists(), SubProblem::vectorTagExists(), SubProblem::vectorTagName(), SubProblem::vectorTagType(), and SubProblem::verifyVectorTags().

◆ _vector_tags_name_map

std::map<TagName, TagID> SubProblem::_vector_tags_name_map

privateinherited

Map of vector tag TagName to TagID.

Definition at line 1181 of file SubProblem.h.

Referenced by SubProblem::addVectorTag(), SubProblem::getVectorTagID(), and SubProblem::verifyVectorTags().

◆ _vector_zero

std::vector<VectorVariableValue> FEProblemBase::_vector_zero

Definition at line 2613 of file FEProblemBase.h.

Referenced by FEProblemBase(), reinitDirac(), updateMaxQps(), and ~FEProblemBase().

◆ _verbose_multiapps

bool FEProblemBase::_verbose_multiapps

protected

Whether or not to be verbose with multiapps.

Definition at line 3552 of file FEProblemBase.h.

Referenced by backupMultiApps(), execMultiApps(), execMultiAppTransfers(), finishMultiAppStep(), restoreMultiApps(), setVerboseProblem(), and verboseMultiApps().

◆ _verbose_restore

bool FEProblemBase::_verbose_restore

protected

Whether or not to be verbose on solution restoration post a failed time step.

Definition at line 3555 of file FEProblemBase.h.

Referenced by restoreSolutions(), and setVerboseProblem().

◆ _verbose_setup

MooseEnum FEProblemBase::_verbose_setup

protected

Whether or not to be verbose during setup.

Definition at line 3549 of file FEProblemBase.h.

Referenced by logAdd(), and setVerboseProblem().

◆ _xfem

std::shared_ptr<XFEMInterface> FEProblemBase::_xfem

protected

Pointer to XFEM controller.

Definition at line 3430 of file FEProblemBase.h.

Referenced by getXFEM(), haveXFEM(), initXFEM(), and updateMeshXFEM().

◆ _zero

std::vector<VariableValue> FEProblemBase::_zero

Definition at line 2603 of file FEProblemBase.h.

Referenced by FEProblemBase(), reinitDirac(), updateMaxQps(), and ~FEProblemBase().

◆ _zero_block_material_props

std::map<SubdomainID, std::set<MaterialPropertyName> > SubProblem::_zero_block_material_props

protectedinherited

Set of properties returned as zero properties.

Definition at line 1059 of file SubProblem.h.

Referenced by SubProblem::checkBlockMatProps(), checkDependMaterialsHelper(), and SubProblem::storeSubdomainZeroMatProp().

◆ _zero_boundary_material_props

std::map<BoundaryID, std::set<MaterialPropertyName> > SubProblem::_zero_boundary_material_props

protectedinherited

Definition at line 1060 of file SubProblem.h.

Referenced by SubProblem::checkBoundaryMatProps(), and SubProblem::storeBoundaryZeroMatProp().

◆ app_param

const std::string MooseBase::app_param = "_moose_app"

staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

Referenced by addAnyRedistributers(), MeshGenerator::addMeshSubgenerator(), InputParameters::callMooseError(), ActionFactory::create(), ActionFactory::getValidParams(), Factory::getValidParams(), AutomaticMortarGeneration::initOutput(), SetupMeshAction::modifyParamsForUseSplit(), and MortarNodalGeometryOutput::validParams().

◆ kokkos_object_param

const std::string MooseBase::kokkos_object_param = "_kokkos_object"

staticinherited

The name of the parameter that indicates an object is a Kokkos functor.

Definition at line 64 of file MooseBase.h.

Referenced by InputParameters::isKokkosObject().

◆ moose_base_param

const std::string MooseBase::moose_base_param = "_moose_base"

staticinherited

The name of the parameter that contains the moose system base.

Definition at line 61 of file MooseBase.h.

Referenced by InputParameters::getBase(), InputParameters::hasBase(), and InputParameters::registerBase().

◆ name_param

const std::string MooseBase::name_param = "_object_name"

staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), AppFactory::create(), InputParameters::getObjectName(), AutomaticMortarGeneration::initOutput(), InputParameters::isMooseBaseObject(), MooseMesh::prepare(), CouplingFunctorCheckAction::validParams(), and MooseBase::validParams().

◆ type_param

const std::string MooseBase::type_param = "_type"

staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

Referenced by ActionFactory::create(), AppFactory::create(), InputParameters::getObjectType(), Factory::initialize(), InputParameters::isMooseBaseObject(), InputParameters::queryObjectType(), MooseBase::validParams(), and MortarNodalGeometryOutput::validParams().

◆ unique_name_param

const std::string MooseBase::unique_name_param = "_unique_name"

staticinherited

The name of the parameter that contains the unique object name.

Definition at line 57 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), AppFactory::create(), InputParameterWarehouse::removeInputParameters(), MooseBase::uniqueName(), and MooseBase::validParams().

◆ usingCombinedWarningSolutionWarnings

MooseObject::usingCombinedWarningSolutionWarnings

inherited

Definition at line 67 of file MooseObject.h.

The documentation for this class was generated from the following files:

include/problems/FEProblemBase.h
src/problems/FEProblemBase.C

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Member Enumeration Documentation

◆ CoverageCheckMode

◆ TrueFunctorIs

Constructor & Destructor Documentation

◆ FEProblemBase()

◆ ~FEProblemBase()

Member Function Documentation

◆ _setCLIOption()

◆ acceptInvalidSolution()

◆ adaptivity()

◆ adaptMesh()

◆ addAlgebraicGhostingFunctor()

◆ addAnyRedistributers()

◆ addAuxArrayVariable()

◆ addAuxKernel()

◆ addAuxScalarKernel()

◆ addAuxScalarVariable()

◆ addAuxVariable() [1/2]

◆ addAuxVariable() [2/2]

◆ addBoundaryCondition()

◆ addCachedJacobian()

◆ addCachedResidual()

◆ addCachedResidualDirectly()

◆ addConstraint()

◆ addConsumedPropertyName()

◆ addConvergence()

◆ addCouplingGhostingFunctor()

◆ addDamper()

◆ addDefaultMultiAppFixedPointConvergence()

◆ addDefaultNonlinearConvergence()

◆ addDefaultSteadyStateConvergence()

◆ addDGKernel()

◆ addDiracKernel()

◆ addDisplacedProblem()

◆ addDistribution()

◆ addElementalFieldVariable()

◆ addFunction()

◆ addFunctor()

◆ addFunctorMaterial()

◆ addFVBC()

◆ addFVGradientMethod()

◆ addFVInitialCondition()

◆ addFVInterfaceKernel()

◆ addFVInterpolationMethod()

◆ addFVKernel()

◆ addGhostedBoundary()

◆ addGhostedElem()

◆ addHDGKernel()

◆ addIndicator()

◆ addInitialCondition()

◆ addInterfaceKernel()

◆ addInterfaceMaterial()

◆ addJacobian()

◆ addJacobianBlockTags()

◆ addJacobianLowerD()

◆ addJacobianNeighbor() [1/3]

◆ addJacobianNeighbor() [2/3]

◆ addJacobianNeighbor() [3/3]

◆ addJacobianNeighborLowerD()

◆ addJacobianOffDiagScalar()

◆ addJacobianScalar()

◆ addKernel()

◆ addKokkosAuxKernel()

◆ addKokkosBoundaryCondition()