MFEMEigenproblem Class Reference

#include <MFEMEigenproblem.h>

Inheritance diagram for MFEMEigenproblem:

Public Types
enum class	NumericType { REAL , COMPLEX }
	Enumerates the supported numeric representations for MFEM variables and operators. More...
enum class	Direction : unsigned char { TO_EXTERNAL_APP , FROM_EXTERNAL_APP }
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
	MFEMEigenproblem (const InputParameters &params)
virtual	~MFEMEigenproblem ()
virtual void	resolveMFEMSolvers () override
	Construct recorded MFEM solvers in dependency order and select the problem driver solver(s).
virtual void	addVariable (const std::string &var_type, const std::string &var_name, InputParameters &parameters) override
	Override of MFEMProblem::addVariable.
Moose::MFEM::EigenRHSCoefficient	getRHSCoefficient ()
	Returns the coefficient used to scale the right-hand side of the eigenproblem equation.
virtual std::shared_ptr< MFEMWeakFormBase >	addDefaultWeakForm () override
	Add default weak form if none has been added by the user.
virtual std::shared_ptr< MFEMProblemComposer >	addDefaultProblemComposer () override
	Add default problem composer if none has been added by the user.
virtual void	initialSetup () override
virtual void	execute (const ExecFlagType &exec_type) override
	Convenience function for performing execution of MOOSE systems.
virtual void	externalSolve () override
	New interface for solving an External problem.
virtual void	syncSolutions (Direction) override
	Method to transfer data to/from the external application to the associated transfer mesh.
virtual MFEMMesh &	mesh () override
	Overwritten mesh() method from base MooseMesh to retrieve the correct mesh type, in this case MFEMMesh.
virtual const MFEMMesh &	mesh () const override
const MooseMesh &	mesh (bool use_displaced) const override
MooseMesh &	mesh (bool use_displaced)
virtual std::vector< VariableName >	getAuxVariableNames ()
	Returns all the variable names from the auxiliary system base.
template<typename T >
std::vector< std::shared_ptr< T > >	addObject (const std::string &type, const std::string &name, InputParameters &parameters)
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.
void	addBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters &parameters) override
void	addMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters) override
void	addFunctorMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters) override
void	addFESpace (const std::string &type, const std::string &name, InputParameters &parameters)
	Add an MFEM FESpace to the problem.
void	addFESpaceHierarchy (const std::string &type, const std::string &name, InputParameters &parameters)
	Add an MFEMFESpaceHierarchy to the problem.
void	setMesh ()
	Set the mesh used by MFEM.
void	addSubMesh (const std::string &type, const std::string &name, InputParameters &parameters)
	Add an MFEM SubMesh to the problem.
void	addTransfer (const std::string &transfer_name, const std::string &name, InputParameters &parameters) override
	Add transfers between MultiApps and/or MFEM SubMeshes.
void	addGridFunction (const std::string &var_type, const std::string &var_name, InputParameters &parameters)
	Adds one MFEM GridFunction to be used in the MFEM solve.
void	addAuxVariable (const std::string &var_type, const std::string &var_name, InputParameters &parameters) override
	Override of ExternalProblem::addAuxVariable.
virtual void	addAuxVariable (const std::string &var_name, const libMesh::FEType &type, const std::set< SubdomainID > *const active_subdomains=NULL)
void	addElementalFieldVariable (const std::string &, const std::string &, InputParameters &) override
	Override of FEProblemBase::addElementalFieldVariable to be a no-op because we do not use the Marker/Indicator objects designed to work with libMesh infrastructure.
void	addKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters) override
	Override of ExternalProblem::addKernel.
void	addRealComponentToKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
	Adds a real component kernel to the parent MFEMComplexKernel.
void	addImagComponentToKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
	Adds an imaginary component kernel to the parent MFEMComplexKernel.
void	addRealComponentToBC (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
	Adds a real component BC to the parent MFEMComplexIntegratedBC.
void	addImagComponentToBC (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
	Adds an imaginary component BC to the parent MFEMComplexIntegratedBC.
void	addWeakForm (const std::string &weak_form_name, const std::string &name, InputParameters &parameters)
	Add an MFEM WeakForm to the problem.
void	setEquationSystems ()
	Set all MFEM EquationSystems for this problem.
std::shared_ptr< Moose::MFEM::EquationSystem >	getEquationSystem (const std::string &weak_form_name="") const
	Return the EquationSystem built by the weak form named weak_form_name.
void	addProblemComposer (const std::string &composer_type, const std::string &name, InputParameters &parameters)
	Method called in AddMFEMProblemComposerAction which will create the problem composer.
void	setProblemOperators ()
	Set all MFEM ProblemOperators to solve in this problem.
std::vector< std::shared_ptr< Moose::MFEM::ProblemOperatorBase > > &	getProblemOperators ()
	Get vector of all ProblemOperators added to this problem.
void	addAuxKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters) override
	Override of ExternalProblem::addAuxKernel.
void	addFunction (const std::string &type, const std::string &name, InputParameters &parameters) override
	Override of ExternalProblem::addFunction.
void	addInitialCondition (const std::string &ic_name, const std::string &name, InputParameters &parameters) override
	Add an MFEM initial condition to the problem.
void	addPostprocessor (const std::string &type, const std::string &name, InputParameters &parameters) override
	Override of ExternalProblem::addPostprocessor.
void	addVectorPostprocessor (const std::string &type, const std::string &name, InputParameters &parameters) override
	Add a vector postprocessor and register its vectors with the MFEM execution system.
void	addIndicator (const std::string &type, const std::string &name, InputParameters &parameters) override
	Override of FEProblemBase::addIndicator.
void	addMarker (const std::string &type, const std::string &name, InputParameters &parameters) override
	Override of FEProblemBase::addMarker.
virtual void	addMFEMSolver (const std::string &user_object_name, const std::string &name, InputParameters &parameters)
	Method called in AddMFEMSolverAction which records a solver for later dependency-ordered construction.
void	executeMFEMObjects (const ExecFlagType &exec_type)
	Execute MFEM executed objects scheduled on the supplied execute flag.
InputParameters	addMFEMFESpaceFromMOOSEVariable (InputParameters &moosevar_params)
	Method used to get an mfem FEC depending on the variable family specified in the input file.
Moose::MFEM::CoefficientManager &	getCoefficients ()
	Method to get the PropertyManager object for storing material properties and converting them to MFEM coefficients.
MFEMProblemData &	getProblemData ()
	Method to get the current MFEMProblemData object storing the current data specifying the FE problem.
const MFEMProblemData &	getProblemData () const
	Return the current MFEM problem data in a const context.
MPI_Comm	getComm ()
	Return the MPI communicator associated with this FE problem's mesh.
const mfem::ParMesh &	getMFEMVariableMesh (std::string var_name)
	Return the ParMesh associated with a particular variable.
void	displaceMesh ()
	Displace the mesh, if mesh displacement is enabled.
void	rebalanceMesh (mfem::ParMesh &pmesh)
	Rebalance the (necessarily nonconforming) mesh.
const mfem::ParGridFunction &	getMeshDisplacementGridFunction ()
	Returns reference to the displacement GridFunction to apply to nodes.
Moose::FEBackend	feBackend () const override
std::string	solverTypeString (unsigned int solver_sys_num) override
	Return solver type as a human readable string.
void	updateFESpaces ()
	Calls Update() on all FE spaces.
void	updateGridFunctions ()
	Calls Update() on all gridfunctions.
bool	hRefine ()
	If AMR is enabled, request (and perform if needed) h-refinement.
bool	pRefine ()
	If AMR is enabled, request (and perform if needed) p-refinement.
std::shared_ptr< mfem::ParGridFunction >	getGridFunction (const std::string &name)
std::shared_ptr< mfem::ParComplexGridFunction >	getComplexGridFunction (const std::string &name)
NumericType	getNumericType () const
	Retrieve the numeric type of the problem.
template<typename T >
T &	getMFEMObject (const std::string &system, const std::string &name, const THREAD_ID tid=0) const
	Retrieve an MFEM object from the warehouse by system and name.
bool	hasMFEMObject (const std::string &system, const std::string &name) const
	Determine whether an MFEM object with the supplied system and name exists.
mfem::AssemblyLevel	assemblyLevel () const
	Return the default assembly level to use for EquationSystem assembly.
void	setAssemblyLevel (mfem::AssemblyLevel assembly_level)
	Set the default assembly level to use for EquationSystem assembly.
virtual void	solve (unsigned int nl_sys_num=0) override final
	Solve is implemented to providing syncing to/from the "transfer" mesh.
virtual void	addExternalVariables ()
	Method called to add AuxVariables to the simulation.
bool	initialized () const
virtual libMesh::EquationSystems &	es () override
void	setCoordSystem (const std::vector< SubdomainName > &blocks, const MultiMooseEnum &coord_sys)
void	setAxisymmetricCoordAxis (const MooseEnum &rz_coord_axis)
void	setCoupling (Moose::CouplingType type)
	Set the coupling between variables TODO: allow user-defined coupling.
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.
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)
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	checkDuplicatePostprocessorVariableNames ()
void	timestepSetup () override
void	customSetup (const ExecFlagType &exec_type) override
void	residualSetup () override
void	jacobianSetup () override
virtual void	prepare (const Elem *elem, const THREAD_ID tid) override
virtual void	prepare (const Elem *elem, unsigned int ivar, unsigned int jvar, const std::vector< dof_id_type > &dof_indices, const THREAD_ID tid) override
virtual void	prepareFace (const Elem *elem, const THREAD_ID tid) override
virtual void	setCurrentSubdomainID (const Elem *elem, const THREAD_ID tid) override
virtual void	setNeighborSubdomainID (const Elem *elem, unsigned int side, const THREAD_ID tid) override
virtual void	setNeighborSubdomainID (const Elem *elem, const THREAD_ID tid)
virtual void	prepareAssembly (const THREAD_ID tid) override
virtual void	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
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 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 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	addHDGKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addNodalKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosNodalKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosBoundaryCondition (const std::string &bc_name, const std::string &name, InputParameters &parameters)
virtual void	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	addAuxArrayVariable (const std::string &var_name, const libMesh::FEType &type, unsigned int components, const std::set< SubdomainID > *const active_subdomains=NULL)
virtual void	addAuxScalarVariable (const std::string &var_name, libMesh::Order order, Real scale_factor=1., const std::set< SubdomainID > *const active_subdomains=NULL)
virtual void	addAuxScalarKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosAuxKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
AuxiliarySystem &	getAuxiliarySystem ()
virtual void	addDiracKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addDGKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addFVKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addLinearFVKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addFVBC (const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
virtual void	addLinearFVBC (const std::string &fv_bc_name, const std::string &name, InputParameters &parameters)
virtual void	addFVInterfaceKernel (const std::string &fv_ik_name, const std::string &name, InputParameters &parameters)
virtual void	addInterfaceKernel (const std::string &kernel_name, const std::string &name, InputParameters &parameters)
virtual void	addFVInitialCondition (const std::string &ic_name, const std::string &name, InputParameters &parameters)
	Add an initial condition for a finite volume variables.
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	addMaterialHelper (std::vector< MaterialWarehouse * > warehouse, const std::string &material_name, const std::string &name, InputParameters &parameters)
virtual void	addInterfaceMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters)
virtual void	addKokkosMaterial (const std::string &material_name, const std::string &name, InputParameters &parameters)
void	prepareMaterials (const std::unordered_set< unsigned int > &consumer_needed_mat_props, const SubdomainID blk_id, const THREAD_ID tid)
	Add the MooseVariables and the material properties that the current materials depend on to the dependency list.
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.
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	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.
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)
void	appendConstantModes (const std::vector< VariableName > &vars, const std::string &prefix, std::vector< NumericVector< libMesh::Number > * > &sp)
	Append one mode per variable of vars in the current nonlinear system to 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	setResidual (libMesh::NumericVector< libMesh::Number > &residual, const THREAD_ID tid)=0
virtual void	setResidualNeighbor (NumericVector< libMesh::Number > &residual, const THREAD_ID tid) override
virtual void	setResidualNeighbor (libMesh::NumericVector< libMesh::Number > &residual, const THREAD_ID tid)=0
virtual void	addJacobian (const THREAD_ID tid) override
virtual void	addJacobianNeighbor (const THREAD_ID tid) override
virtual void	addJacobianNeighbor (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices, std::vector< dof_id_type > &neighbor_dof_indices, const std::set< TagID > &tags, const THREAD_ID tid) override
virtual void	addJacobianNeighbor (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const libMesh::DofMap &dof_map, std::vector< dof_id_type > &dof_indices, std::vector< dof_id_type > &neighbor_dof_indices, const std::set< TagID > &tags, const THREAD_ID tid)=0
virtual void	addJacobianNeighborLowerD (const THREAD_ID tid) override
virtual void	addJacobianLowerD (const THREAD_ID tid) override
virtual void	addJacobianBlockTags (libMesh::SparseMatrix< libMesh::Number > &jacobian, unsigned int ivar, unsigned int jvar, const DofMap &dof_map, std::vector< dof_id_type > &dof_indices, const std::set< TagID > &tags, const THREAD_ID tid)
virtual void	addJacobianScalar (const THREAD_ID tid=0)
virtual void	addJacobianOffDiagScalar (unsigned int ivar, const THREAD_ID tid=0)
virtual void	cacheJacobian (const THREAD_ID tid) override
virtual void	cacheJacobianNeighbor (const THREAD_ID tid) override
virtual void	addCachedJacobian (const THREAD_ID tid) override
virtual void	prepareShapes (unsigned int var, const THREAD_ID tid) override
virtual void	prepareFaceShapes (unsigned int var, const THREAD_ID tid) override
virtual void	prepareNeighborShapes (unsigned int var, const THREAD_ID tid) override
virtual void	addDisplacedProblem (std::shared_ptr< DisplacedProblem > displaced_problem)
virtual std::shared_ptr< const DisplacedProblem >	getDisplacedProblem () const
virtual std::shared_ptr< DisplacedProblem >	getDisplacedProblem ()
virtual void	updateGeomSearch (GeometricSearchData::GeometricSearchType type=GeometricSearchData::ALL) override
	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	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.
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	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.
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.
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	automaticScaling (bool automatic_scaling)
	Automatic scaling setter.
bool	automaticScaling () const
	Automatic scaling getter.
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
void	fvBCsIntegrityCheck (bool fv_bcs_integrity_check)
bool	sideUOInterfaceMatPropIntegrityCheck () const
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
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.
const bool &	currentlyComputingResidual () const
	Returns true if the problem is in the process of computing the residual.
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 ()
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
void	validateVariableNumericType (const std::string &var_type, const std::string &var_name) const
	Verify that a primary variable's numeric type matches the problem's equation system.
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
MFEMProblemData	_problem_data
	Aggregated MFEM-side state for meshes, spaces, variables, coefficients, and solvers.
NumericType	_num_type
	The numeric representation currently active for this problem.
std::map< std::string, MFEMSolverDefinition >	_mfem_solver_definitions
	Solver definitions recorded by AddMFEMSolverAction before the dependency resolver constructs them.
Moose::MFEM::SolutionState &	_solution_state_data
	Restartable MFEM solution state associated with this problem.
std::shared_ptr< MFEMProblemComposer >	_problem_composer
	The problem operator builders for this mfem problem.
std::vector< std::shared_ptr< Moose::MFEM::ProblemOperatorBase > >	_problem_operators
	Vector of MFEM problem operators executed in this problem.
mfem::AssemblyLevel	_assembly_level {mfem::AssemblyLevel::LEGACY}
	Default assembly level to use for EquationSystem assembly.
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	_interface_kernel_integrity_check
	Whether to check that interface kernel variables match the orientation of their boundaries.
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 std::vector< VariableName >	_constant_null_space_vars
	Variables whose constant fields span part of the Jacobian nullspace.
const std::vector< VariableName >	_constant_transpose_null_space_vars
	Variables whose constant fields span part of the Jacobian transpose nullspace.
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	translateCaughtException (const std::string &calling_method)
	Classify the exception currently being handled and register its message with setException(), or error if the exception cannot be recovered from.
void	handleException (const std::string &calling_method)
	Handle exceptions.
void	translateUserObjectExceptions (const std::function< void()> &work)
	Execute work, user object computations local to this process, and register any exception it raises with translateCaughtException() instead of letting it propagate, so that this process does not skip communication entered by the other processes.
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.

Detailed Description

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

stronginherited

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

Direction

enum class ExternalProblem::Direction : unsigned char

stronginherited

Enumerator
TO_EXTERNAL_APP
FROM_EXTERNAL_APP

Definition at line 21 of file ExternalProblem.h.

  {
    TO_EXTERNAL_APP,
    FROM_EXTERNAL_APP
  };

NumericType

enum class MFEMProblem::NumericType

stronginherited

Enumerates the supported numeric representations for MFEM variables and operators.

Enumerator
REAL
COMPLEX

Definition at line 405 of file MFEMProblem.h.

  {
    REAL,
    COMPLEX
  };

TrueFunctorIs

enum class SubProblem::TrueFunctorIs

strongprivateinherited

Enumerator
UNSET
NONAD
AD

Definition at line 1130 of file SubProblem.h.

  {
    UNSET,
    NONAD,
    AD
  };

Constructor & Destructor Documentation

MFEMEigenproblem()

MFEMEigenproblem::MFEMEigenproblem

(

const InputParameters &

params

)

Definition at line 42 of file MFEMEigenproblem.C.

                                                                 : MFEMProblem(params)
{
  getProblemData().mode_separator = getParam<std::string>("mode_separator");
  if (_num_type == NumericType::COMPLEX)
    mooseError("Complex numbers are not currently supported for eigenproblems.");
 
  if (isParamSetByUser("rhs_matrix_coefficient") && isParamSetByUser("rhs_coefficient"))
    paramError("rhs_coefficient",
               "Only one of 'rhs_coefficient' and 'rhs_matrix_coefficient' may be set to a "
               "non-default value.");
}

~MFEMEigenproblem()

virtual MFEMEigenproblem::~MFEMEigenproblem ( )

inlinevirtual

Definition at line 23 of file MFEMEigenproblem.h.

{}

Member Function Documentation

_setCLIOption()

void Problem::_setCLIOption ( )

inlineinherited

For Internal Use.

Definition at line 32 of file Problem.h.

{ _cli_option_found = true; }

acceptInvalidSolution()

bool FEProblemBase::acceptInvalidSolution ( ) const

inherited

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

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

Definition at line 4375 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 ( )

inlineinherited

Definition at line 2194 of file FEProblemBase.h.

{ return _adaptivity; }

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

adaptMesh()

bool FEProblemBase::adaptMesh ( )

virtualinherited

Returns

Whether or not the mesh was changed

Reimplemented in DumpObjectsProblem.

Definition at line 9294 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 ( )

privateinherited

Definition at line 7091 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  )

virtualinherited

Definition at line 3674 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 MFEMProblem::addAuxKernel ( const std::string &  kernel_name, const std::string &  name, InputParameters &  parameters  )

overridevirtualinherited

Override of ExternalProblem::addAuxKernel.

Creates the MOOSE-side MFEM auxkernel wrapper.

Reimplemented from FEProblemBase.

Definition at line 382 of file MFEMProblem.C.

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

addAuxScalarKernel()

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

virtualinherited

Definition at line 3756 of file FEProblemBase.C.

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

addAuxScalarVariable()

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

virtualinherited

Definition at line 3705 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  )

virtualinherited

Reimplemented in DumpObjectsProblem.

addAuxVariable() [2/2]

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

overridevirtualinherited

Override of ExternalProblem::addAuxVariable.

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

Reimplemented from FEProblemBase.

Definition at line 372 of file MFEMProblem.C.

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

addBoundaryCondition()

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

overridevirtualinherited

Reimplemented from FEProblemBase.

Definition at line 233 of file MFEMProblem.C.

{
  auto bc = addObject<MFEMBoundaryCondition>(bc_name, name, parameters).front();
  _problem_data.bcs.Register(name, bc);
}

addCachedJacobian()

void FEProblemBase::addCachedJacobian ( const THREAD_ID  tid )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2422 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 )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2293 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  )

virtualinherited

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

Parameters

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

Definition at line 2301 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  )

virtualinherited

Definition at line 3547 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  )

virtualinherited

Adds a Convergence object.

Definition at line 2930 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 FEProblemBase::addDefaultMultiAppFixedPointConvergence(), FEProblemBase::addDefaultNonlinearConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), and FEProblemBase::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  )

virtualinherited

Definition at line 6121 of file FEProblemBase.C.

{
  parallel_object_only();
 
  const auto nl_sys_num =
      parameters.isParamValid("variable")
          ? determineSolverSystem(parameters.varName("variable", name), true).second
          : (unsigned int)0;
 
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a DGKernel to a linear variable/system, which is not "
               "supported at the moment!");
 
  parameters.set<SubProblem *>("_subproblem") = this;
  parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
 
  _has_dampers = true;
  logAdd("Damper", name, damper_name, parameters);
  _nl[nl_sys_num]->addDamper(damper_name, name, parameters);
}

addDefaultMultiAppFixedPointConvergence()

void FEProblemBase::addDefaultMultiAppFixedPointConvergence ( const InputParameters &  params )

inherited

Adds the default fixed point Convergence associated with the problem.

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

Parameters

[in]

params

Parameters to apply to Convergence parameters

Definition at line 2956 of file FEProblemBase.C.

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

addDefaultNonlinearConvergence()

void FEProblemBase::addDefaultNonlinearConvergence ( const InputParameters &  params )

virtualinherited

Adds the default nonlinear Convergence associated with the problem.

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

Parameters

[in]

params

Parameters to apply to Convergence parameters

Reimplemented in ReferenceResidualProblem.

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

addDefaultProblemComposer()

std::shared_ptr< MFEMProblemComposer > MFEMEigenproblem::addDefaultProblemComposer ( )

overridevirtual

Add default problem composer if none has been added by the user.

Reimplemented from MFEMProblem.

Definition at line 130 of file MFEMEigenproblem.C.

{
  InputParameters params = _factory.getValidParams("MFEMEigenWeakFormProblemComposer");
  return addObject<MFEMProblemComposer>(
             "MFEMEigenWeakFormProblemComposer", "__DefaultWeakFormProblemComposer", params)
      .front();
}

addDefaultSteadyStateConvergence()

void FEProblemBase::addDefaultSteadyStateConvergence ( const InputParameters &  params )

inherited

Adds the default steady-state detection Convergence.

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

Parameters

[in]

params

Parameters to apply to Convergence parameters

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

addDefaultWeakForm()

std::shared_ptr< MFEMWeakFormBase > MFEMEigenproblem::addDefaultWeakForm ( )

overridevirtual

Add default weak form if none has been added by the user.

Reimplemented from MFEMProblem.

Definition at line 118 of file MFEMEigenproblem.C.

{
  if (getNumericType() != MFEMProblem::NumericType::REAL)
    mooseError("Complex MFEM eigenproblems are not currently supported. Please set the Problem "
               "numeric type to 'real'.");
 
  InputParameters parameters = _factory.getValidParams("MFEMEigenproblemWeakForm");
  return addObject<MFEMWeakFormBase>("MFEMEigenproblemWeakForm", "__DefaultWeakForm", parameters)
      .front();
}

addDGKernel()

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

virtualinherited

Definition at line 3828 of file FEProblemBase.C.

{
  parallel_object_only();
 
  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a DGKernel to a linear variable/system, which is not "
               "supported at the moment!");
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
    _reinit_displaced_neighbor = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow DGKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this DGKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }
 
  logAdd("DGKernel", name, dg_kernel_name, parameters);
  _nl[nl_sys_num]->addDGKernel(dg_kernel_name, name, parameters);
 
  _has_internal_edge_residual_objects = true;
}

addDiracKernel()

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

virtualinherited

Definition at line 3788 of file FEProblemBase.C.

{
  parallel_object_only();
 
  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a DiracKernel to a linear variable/system, which is not "
               "supported at the moment!");
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
    _reinit_displaced_elem = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow DiracKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this DiracKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }
 
  logAdd("DiracKernel", name, kernel_name, parameters);
  _nl[nl_sys_num]->addDiracKernel(kernel_name, name, parameters);
}

addDisplacedProblem()

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

virtualinherited

Definition at line 9093 of file FEProblemBase.C.

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

addDistribution()

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

virtualinherited

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

Definition at line 3103 of file FEProblemBase.C.

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

addElementalFieldVariable()

void MFEMProblem::addElementalFieldVariable ( const std::string &  , const std::string &  , InputParameters &    )

inlineoverridevirtualinherited

Override of FEProblemBase::addElementalFieldVariable to be a no-op because we do not use the Marker/Indicator objects designed to work with libMesh infrastructure.

Reimplemented from FEProblemBase.

Definition at line 144 of file MFEMProblem.h.

  {
  }

addExternalVariables()

virtual void ExternalProblem::addExternalVariables ( )

inlinevirtualinherited

Method called to add AuxVariables to the simulation.

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

Definition at line 48 of file ExternalProblem.h.

{}

addFESpace()

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

inherited

Add an MFEM FESpace to the problem.

Definition at line 257 of file MFEMProblem.C.

{
  if (getProblemData().fespace_hierarchies.Has(name))
    mooseError("Cannot add FESpace '",
               name,
               "': an MFEMFESpaceHierarchy with the same name already exists. "
               "FESpaces and FESpaceHierarchies share the fespaces namespace.");
 
  auto & mfem_fespace = *addObject<MFEMFESpace>(type, name, parameters).front();
 
  // Register fespace and associated fe collection.
  getProblemData().fecs.Register(name, mfem_fespace.getFEC());
  getProblemData().fespaces.Register(name, mfem_fespace.getFESpace());
}

Referenced by MFEMProblem::addMFEMFESpaceFromMOOSEVariable().

addFESpaceHierarchy()

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

inherited

Add an MFEMFESpaceHierarchy to the problem.

Definition at line 275 of file MFEMProblem.C.

{
  if (getProblemData().fespaces.Has(name))
    mooseError("Cannot add MFEMFESpaceHierarchy '",
               name,
               "': a FESpace with the same name already exists. "
               "FESpaces and FESpaceHierarchies share the fespaces namespace.");
 
  auto hierarchy_obj = addObject<MFEMFESpaceHierarchy>(type, name, parameters).front();
  auto hierarchy_shared = hierarchy_obj->getHierarchyShared();
  // Register the hierarchy for co-ownership by solvers.
  getProblemData().fespace_hierarchies.Register(name, hierarchy_shared);
  // Register the finest-level FESpace in fespaces under the hierarchy name so that
  // variables can say `fespace = <hierarchy_name>` without a separate FESpace definition.
  // The aliasing shared_ptr keeps the hierarchy alive as long as this entry lives.
  auto finest = std::shared_ptr<mfem::ParFiniteElementSpace>(
      hierarchy_shared, &hierarchy_obj->getHierarchy().GetFinestFESpace());
  getProblemData().fespaces.Register(name, finest);
}

addFunction()

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

overridevirtualinherited

Override of ExternalProblem::addFunction.

Creates a corresponding MFEM Coefficient or VectorCoefficient object for the added MOOSE function.

Reimplemented from FEProblemBase.

Definition at line 622 of file MFEMProblem.C.

{
  // Add function to the warehouse, while avoiding the threading logic in FEProblemBase::addFunction
  {
    parallel_object_only();
 
    parameters.set<SubProblem *>("_subproblem") = this;
 
    std::shared_ptr<Function> func = _factory.create<Function>(type, name, parameters);
    logAdd("Function", name, type, parameters);
    _functions.addObject(func);
  }
 
  auto & func = getFunction(name);
  // FIXME: Do we want to have optimised versions for when functions
  // are only of space or only of time.
  if (std::find(SCALAR_FUNCS.begin(), SCALAR_FUNCS.end(), type) != SCALAR_FUNCS.end())
  {
    getCoefficients().declareScalar<mfem::FunctionCoefficient>(
        name,
        [&func](const mfem::Vector & p, mfem::real_t t) -> mfem::real_t
        { return func.value(t, Moose::MFEM::libMeshPointFromMFEMVector(p)); });
  }
  else if (std::find(VECTOR_FUNCS.begin(), VECTOR_FUNCS.end(), type) != VECTOR_FUNCS.end())
  {
    int dim = vectorFunctionDim(type, parameters);
    getCoefficients().declareVector<mfem::VectorFunctionCoefficient>(
        name,
        dim,
        [&func, dim](const mfem::Vector & p, mfem::real_t t, mfem::Vector & u)
        {
          libMesh::RealVectorValue vector_value =
              func.vectorValue(t, Moose::MFEM::libMeshPointFromMFEMVector(p));
          for (int i = 0; i < dim; i++)
          {
            u[i] = vector_value(i);
          }
        });
  }
  else if (std::find(MFEM_FUNCS.begin(), MFEM_FUNCS.end(), type) != MFEM_FUNCS.end())
  {
  }
  else
    mooseWarning("Could not identify function ", type, "; no MFEM coefficient object created.");
}

addFunctor()

template<typename T >

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

inherited

add a functor to the problem functor container

Definition at line 1371 of file SubProblem.h.

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

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

addFunctorMaterial()

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

overridevirtualinherited

Reimplemented from FEProblemBase.

Definition at line 249 of file MFEMProblem.C.

{
  addObject<MFEMFunctorMaterial>(material_name, name, parameters);
}

addFVBC()

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

virtualinherited

Definition at line 3882 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  )

virtualinherited

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

virtualinherited

Add an initial condition for a finite volume variables.

Parameters

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

Definition at line 4061 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  )

virtualinherited

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

Definition at line 3890 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  )

virtualinherited

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

virtualinherited

Definition at line 3868 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 )

overridevirtualinherited

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

Implements SubProblem.

Definition at line 2518 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 )

overridevirtualinherited

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

Implements SubProblem.

Definition at line 2511 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().

addGridFunction()

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

inherited

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

Definition at line 332 of file MFEMProblem.C.

{
 
  if (var_type == "MFEMVariable" || var_type == "MFEMComplexVariable")
  {
    // Add MFEM variable directly.
    if (var_type == "MFEMComplexVariable")
      addObject<MFEMComplexVariable>(var_type, var_name, parameters);
    else
      addObject<MFEMVariable>(var_type, var_name, parameters);
  }
  else
  {
    // Add MOOSE variable.
    ExternalProblem::addVariable(var_type, var_name, parameters);
 
    // Add MFEM variable indirectly ("gridfunction").
    InputParameters mfem_variable_params = addMFEMFESpaceFromMOOSEVariable(parameters);
    addObject<MFEMVariable>("MFEMVariable", var_name, mfem_variable_params);
  }
 
  // Register gridfunction.
  if (var_type == "MFEMComplexVariable")
  {
    MFEMComplexVariable & mfem_variable =
        getMFEMObject<MFEMComplexVariable>("MooseVariableBase", var_name);
    getProblemData().cmplx_gridfunctions.Register(var_name, mfem_variable.getComplexGridFunction());
    mfem_variable.declareCoefficients();
  }
  else // must be real, but may have been set up indirectly from a MOOSE variable
  {
    MFEMVariable & mfem_variable = getMFEMObject<MFEMVariable>("MooseVariableBase", var_name);
    getProblemData().gridfunctions.Register(var_name, mfem_variable.getGridFunction());
    mfem_variable.declareCoefficients();
  }
}

Referenced by MFEMProblem::addAuxVariable(), addVariable(), and MFEMProblem::addVariable().

addHDGKernel()

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

virtualinherited

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

addImagComponentToBC()

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

inherited

Adds an imaginary component BC to the parent MFEMComplexIntegratedBC.

Definition at line 438 of file MFEMProblem.C.

{
  auto parent_ptr = std::dynamic_pointer_cast<MFEMComplexIntegratedBC>(
      getMFEMObject<MFEMComplexIntegratedBC>("BoundaryCondition", name).getSharedPtr());
  parameters.set<VariableName>("variable") = parent_ptr->getParam<VariableName>("variable");
  parameters.set<std::vector<BoundaryName>>("boundary") =
      parent_ptr->getParam<std::vector<BoundaryName>>("boundary");
  auto bc_ptr = std::dynamic_pointer_cast<MFEMIntegratedBC>(
      addObject<MFEMBoundaryCondition>(kernel_name, name + "_imag", parameters).front());
  parent_ptr->setImagBC(bc_ptr);
}

addImagComponentToKernel()

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

inherited

Adds an imaginary component kernel to the parent MFEMComplexKernel.

Definition at line 411 of file MFEMProblem.C.

{
  auto parent_ptr = std::dynamic_pointer_cast<MFEMComplexKernel>(
      getMFEMObject<MFEMComplexKernel>("Kernel", name).getSharedPtr());
  parameters.set<VariableName>("variable") = parent_ptr->getParam<VariableName>("variable");
  auto kernel_ptr = addObject<MFEMKernel>(kernel_name, name + "_imag", parameters).front();
  parent_ptr->setImagKernel(kernel_ptr);
}

addIndicator()

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

overridevirtualinherited

Override of FEProblemBase::addIndicator.

Creates the MFEMIndicator used when setting up adaptive mesh refinement later.

Reimplemented from FEProblemBase.

Definition at line 119 of file MFEMProblem.C.

{
  auto estimator = addObject<MFEMIndicator>(indicator_type, name, parameters).front();
 
  // construct the estimator itself
  estimator->createEstimator();
}

addInitialCondition()

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

overridevirtualinherited

Add an MFEM initial condition to the problem.

Reimplemented from FEProblemBase.

Definition at line 852 of file MFEMProblem.C.

{
  addObject<MFEMExecutedObject>(ic_name, name, parameters);
}

addInterfaceKernel()

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

virtualinherited

Definition at line 3929 of file FEProblemBase.C.

{
  parallel_object_only();
 
  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a InterfaceKernel to a linear variable/system, which is not "
               "supported at the moment!");
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
    _reinit_displaced_neighbor = true;
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow InterfaceKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this InterfaceKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }
 
  logAdd("InterfaceKernel", name, interface_kernel_name, parameters);
  _nl[nl_sys_num]->addInterfaceKernel(interface_kernel_name, name, parameters);
 
  _has_internal_edge_residual_objects = true;
}

addInterfaceMaterial()

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

virtualinherited

Definition at line 4425 of file FEProblemBase.C.

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

addJacobian()

void FEProblemBase::addJacobian ( const THREAD_ID  tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 2355 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  )

virtualinherited

Definition at line 2430 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 )

overridevirtualinherited

Implements SubProblem.

Definition at line 2385 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 )

overridevirtualinherited

Implements SubProblem.

Definition at line 2369 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  )

overridevirtualinherited

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 )

overridevirtualinherited

Implements SubProblem.

Definition at line 2377 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  )

virtualinherited

Definition at line 2399 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 )

virtualinherited

Definition at line 2393 of file FEProblemBase.C.

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

Referenced by NonlinearSystemBase::computeScalarKernelsJacobians().

addKernel()

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

overridevirtualinherited

Override of ExternalProblem::addKernel.

Creates the MOOSE-side MFEM kernel wrapper and the corresponding MFEM kernel to be used in the MFEM solve.

Reimplemented from FEProblemBase.

Definition at line 390 of file MFEMProblem.C.

{
  auto kernel = addObject<MFEMKernel>(kernel_name, name, parameters).front();
  _problem_data.kernels.Register(name, kernel);
}

addKokkosAuxKernel()

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

virtualinherited

Referenced by FEProblemBase::addAuxKernel().

addKokkosBoundaryCondition()

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

virtualinherited

Referenced by FEProblemBase::addBoundaryCondition().

addKokkosFunction()

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

virtualinherited

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 FEProblemBase::addFunction(), and FEProblemBase::getKokkosFunction().

addKokkosKernel()

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

virtualinherited

Referenced by FEProblemBase::addKernel().

addKokkosLinearFVBC()

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

virtualinherited

Referenced by FEProblemBase::addLinearFVBC().

addKokkosLinearFVKernel()

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

virtualinherited

Referenced by FEProblemBase::addLinearFVKernel().

addKokkosMaterial()

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

virtualinherited

Referenced by FEProblemBase::addMaterial().

addKokkosMeshInitializationHook()

void FEProblemBase::addKokkosMeshInitializationHook ( std::function< void()>  function )

inlineinherited

Add a function hook that needs to be called after Kokkos mesh initialization.

Parameters

function

The function to be called

Definition at line 3103 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  )

virtualinherited

Referenced by FEProblemBase::addNodalKernel().

addKokkosPostprocessor()

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

virtualinherited

Referenced by FEProblemBase::addPostprocessor().

addKokkosReporter()

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

virtualinherited

Referenced by FEProblemBase::addReporter().

addKokkosUserObject()

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

virtualinherited

Referenced by FEProblemBase::addUserObject().

addKokkosVectorPostprocessor()

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

virtualinherited

Referenced by FEProblemBase::addVectorPostprocessor().

addLinearFVBC()

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

virtualinherited

Definition at line 3914 of file FEProblemBase.C.

{
#ifdef MOOSE_KOKKOS_ENABLED
  if (parameters.isKokkosObject())
    return addKokkosLinearFVBC(bc_name, name, parameters);
#endif
 
  addObject<LinearFVBoundaryCondition>(bc_name, name, parameters);
}

addLinearFVKernel()

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

virtualinherited

Definition at line 3901 of file FEProblemBase.C.

{
#ifdef MOOSE_KOKKOS_ENABLED
  if (parameters.isKokkosObject())
    return addKokkosLinearFVKernel(kernel_name, name, parameters);
#endif
 
  addObject<LinearFVKernel>(kernel_name, name, parameters);
}

addLineSearch()

virtual void FEProblemBase::addLineSearch ( const InputParameters &  )

inlinevirtualinherited

add a MOOSE line search

Reimplemented in DumpObjectsProblem, and FEProblem.

Definition at line 838 of file FEProblemBase.h.

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

Referenced by FEProblemSolve::FEProblemSolve().

addMarker()

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

overridevirtualinherited

Override of FEProblemBase::addMarker.

Creates the MFEMRefinementMarker used for adaptive mesh refinement.

Reimplemented from FEProblemBase.

Definition at line 130 of file MFEMProblem.C.

{
  getProblemData().refiner = addObject<MFEMRefinementMarker>(marker_type, name, parameters).front();
}

addMaterial()

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

overridevirtualinherited

Reimplemented from FEProblemBase.

Definition at line 242 of file MFEMProblem.C.

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

addMaterialHelper()

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

virtualinherited

Definition at line 4433 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 FEProblemBase::addInterfaceMaterial(), and FEProblemBase::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(), FEProblemBase::createTagMatrices(), LinearSystem::LinearSystem(), NonlinearEigenSystem::NonlinearEigenSystem(), and NonlinearSystemBase::NonlinearSystemBase().

addMeshDivision()

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

virtualinherited

Add a MeshDivision.

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

addMFEMFESpaceFromMOOSEVariable()

InputParameters MFEMProblem::addMFEMFESpaceFromMOOSEVariable ( InputParameters &  moosevar_params )

inherited

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

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

Definition at line 706 of file MFEMProblem.C.

{
 
  InputParameters fespace_params = _factory.getValidParams("MFEMGenericFESpace");
  InputParameters variable_params = _factory.getValidParams("MFEMVariable");
 
  const auto family = Utility::string_to_enum<FEFamily>(parameters.get<MooseEnum>("family"));
  auto order = static_cast<int>(parameters.get<MooseEnum>("order"));
  const auto dim = mesh().dimension();
 
  std::string space;
  int vdim = 1;
 
  switch (family)
  {
    case FEFamily::LAGRANGE:
      space = "H1";
      break;
    case FEFamily::NEDELEC_ONE:
      space = "ND";
      break;
    case FEFamily::RAVIART_THOMAS:
      space = "RT";
      --order;
      break;
    case FEFamily::MONOMIAL:
    case FEFamily::L2_LAGRANGE:
      space = "L2";
      break;
    case FEFamily::LAGRANGE_VEC:
      space = "H1";
      vdim = dim;
      break;
    case FEFamily::MONOMIAL_VEC:
    case FEFamily::L2_LAGRANGE_VEC:
      space = "L2";
      vdim = dim;
      break;
    default:
      mooseError("Unable to set MFEM FESpace for MOOSE variable");
      break;
  }
 
  // Create fespace name. If this already exists, we will reuse this for
  // the mfem variable ("gridfunction"). If using AMR, this implies all
  // variables sharing the fespace are affected.
  const auto fec_name = space + "_" + std::to_string(dim) + "D_P" + std::to_string(order);
  const auto fes_name = fec_name + "_X" + std::to_string(vdim);
 
  // Set all fespace parameters.
  fespace_params.set<std::string>("fec_name") = fec_name;
  fespace_params.set<int>("vdim") = vdim;
 
  if (!hasMFEMObject("MFEMFESpace", fes_name))
    addFESpace("MFEMGenericFESpace", fes_name, fespace_params);
 
  variable_params.set<MFEMFESpaceName>("fespace") = fes_name;
 
  return variable_params;
}

Referenced by MFEMProblem::addGridFunction().

addMFEMSolver()

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

virtualinherited

Method called in AddMFEMSolverAction which records a solver for later dependency-ordered construction.

Definition at line 138 of file MFEMProblem.C.

{
  mooseAssert(!_mfem_solver_definitions.count(name), "Multiple MFEM solvers named '" + name + "'.");
  _mfem_solver_definitions.emplace(name, MFEMSolverDefinition{solver_type, &parameters});
}

addMultiApp()

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

virtualinherited

Add a MultiApp to the problem.

Definition at line 6232 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  )

virtualinherited

Definition at line 3449 of file FEProblemBase.C.

{
#ifdef MOOSE_KOKKOS_ENABLED
  if (parameters.isKokkosObject())
    return addKokkosNodalKernel(kernel_name, name, parameters);
#endif
 
  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 FEProblemBase::createTagVectors().

addObject() [1/2]

template<typename T >

std::vector< std::shared_ptr< T > > MFEMProblem::addObject ( const std::string &  type, const std::string &  name, InputParameters &  parameters  )

inlineinherited

Definition at line 70 of file MFEMProblem.h.

  {
    return ExternalProblem::addObject<T>(type, name, parameters, /*threaded=*/false);
  }

addObject() [2/2]

template<typename T >

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

inherited

Method for creating and adding an object to the warehouse.

Template Parameters

T	The base object type (registered in the Factory)

Parameters

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

Returns

A vector of shared_ptrs to the added objects

Definition at line 3861 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"  )

protectedinherited

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

This is needed due to header includes/forward declaration issues

Definition at line 4834 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 FEProblemBase::addFVGradientMethod(), FEProblemBase::addFVInterpolationMethod(), FEProblemBase::addObject(), and FEProblemBase::addUserObject().

addOutput()

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

inherited

Adds an Output object.

Definition at line 10242 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 MFEMProblem::addPostprocessor ( const std::string &  type, const std::string &  name, InputParameters &  parameters  )

overridevirtualinherited

Override of ExternalProblem::addPostprocessor.

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

Reimplemented from FEProblemBase.

Definition at line 671 of file MFEMProblem.C.

{
  if (parameters.getSystemAttributeName() == "MFEMExecutedObject")
  {
    checkUserObjectNameCollision(name, "Postprocessor");
    addObject<MFEMExecutedObject>(type, name, parameters);
  }
  else
    ExternalProblem::addPostprocessor(type, name, parameters);
 
  // Make the postprocessor value available as a spatially uniform scalar coefficient. This is done
  // for postprocessors of all types so that values calculated elsewhere and transferred in, such
  // as from a subapp, may also be used to build coefficients.
  const PostprocessorValue & val = getPostprocessorValueByName(name);
  getCoefficients().declareScalar<mfem::FunctionCoefficient>(
      name, [&val](const mfem::Vector &) -> mfem::real_t { return val; });
}

addPredictor()

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

virtualinherited

Definition at line 8034 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().

addProblemComposer()

void MFEMProblem::addProblemComposer ( const std::string &  composer_type, const std::string &  name, InputParameters &  parameters  )

inherited

Method called in AddMFEMProblemComposerAction which will create the problem composer.

Definition at line 513 of file MFEMProblem.C.

{
  _problem_composer = addObject<MFEMProblemComposer>(composer_type, name, parameters).front();
}

addRealComponentToBC()

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

inherited

Adds a real component BC to the parent MFEMComplexIntegratedBC.

Definition at line 423 of file MFEMProblem.C.

{
  auto parent_ptr = std::dynamic_pointer_cast<MFEMComplexIntegratedBC>(
      getMFEMObject<MFEMComplexIntegratedBC>("BoundaryCondition", name).getSharedPtr());
  parameters.set<VariableName>("variable") = parent_ptr->getParam<VariableName>("variable");
  parameters.set<std::vector<BoundaryName>>("boundary") =
      parent_ptr->getParam<std::vector<BoundaryName>>("boundary");
  auto bc_ptr = std::dynamic_pointer_cast<MFEMIntegratedBC>(
      addObject<MFEMBoundaryCondition>(kernel_name, name + "_real", parameters).front());
  parent_ptr->setRealBC(bc_ptr);
}

addRealComponentToKernel()

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

inherited

Adds a real component kernel to the parent MFEMComplexKernel.

Definition at line 399 of file MFEMProblem.C.

{
  auto parent_ptr = std::dynamic_pointer_cast<MFEMComplexKernel>(
      getMFEMObject<MFEMComplexKernel>("Kernel", name).getSharedPtr());
  parameters.set<VariableName>("variable") = parent_ptr->getParam<VariableName>("variable");
  auto kernel_ptr = addObject<MFEMKernel>(kernel_name, name + "_real", parameters).front();
  parent_ptr->setRealKernel(kernel_ptr);
}

addReporter()

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

virtualinherited

Add a Reporter object to the simulation.

Parameters

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

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

Definition at line 4937 of file FEProblemBase.C.

{
#ifdef MOOSE_KOKKOS_ENABLED
  if (parameters.isKokkosObject())
    return addKokkosReporter(type, name, parameters);
#endif
 
  checkUserObjectNameCollision(name, "Reporter");
 
  addUserObject(type, name, parameters);
}

Referenced by MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer().

addResidual()

void FEProblemBase::addResidual ( const THREAD_ID  tid )

overridevirtualinherited

Implements SubProblem.

Definition at line 2240 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 )

overridevirtualinherited

Implements SubProblem.

Definition at line 2260 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 )

overridevirtualinherited

Implements SubProblem.

Definition at line 2250 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 )

virtualinherited

Definition at line 2270 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  )

virtualinherited

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

Definition at line 3144 of file FEProblemBase.C.

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

addScalarKernel()

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

virtualinherited

Definition at line 3487 of file FEProblemBase.C.

{
  parallel_object_only();
 
  const auto nl_sys_num = determineSolverSystem(parameters.varName("variable", name), true).second;
  if (!isSolverSystemNonlinear(nl_sys_num))
    mooseError("You are trying to add a ScalarKernel to a linear variable/system, which is not "
               "supported at the moment!");
 
  if (_displaced_problem && parameters.get<bool>("use_displaced_mesh"))
  {
    parameters.set<SubProblem *>("_subproblem") = _displaced_problem.get();
    parameters.set<SystemBase *>("_sys") = &_displaced_problem->solverSys(nl_sys_num);
  }
  else
  {
    if (_displaced_problem == nullptr && parameters.get<bool>("use_displaced_mesh"))
    {
      // We allow ScalarKernels to request that they use_displaced_mesh,
      // but then be overridden when no displacements variables are
      // provided in the Mesh block.  If that happened, update the value
      // of use_displaced_mesh appropriately for this ScalarKernel.
      if (parameters.have_parameter<bool>("use_displaced_mesh"))
        parameters.set<bool>("use_displaced_mesh") = false;
    }
 
    parameters.set<SubProblem *>("_subproblem") = this;
    parameters.set<SystemBase *>("_sys") = _nl[nl_sys_num].get();
  }
 
  logAdd("ScalarKernel", name, kernel_name, parameters);
  _nl[nl_sys_num]->addScalarKernel(kernel_name, name, parameters);
}

addSubMesh()

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

inherited

Add an MFEM SubMesh to the problem.

Definition at line 831 of file MFEMProblem.C.

{
  auto & mfem_submesh = *addObject<MFEMSubMesh>(var_type, var_name, parameters).front();
  // Register submesh.
  getProblemData().submeshes.Register(var_name, mfem_submesh.getSubMesh());
}

addTimeIntegrator()

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

virtualinherited

Definition at line 7999 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 MFEMProblem::addTransfer ( const std::string &  transfer_name, const std::string &  name, InputParameters &  parameters  )

overridevirtualinherited

Add transfers between MultiApps and/or MFEM SubMeshes.

Reimplemented from FEProblemBase.

Definition at line 841 of file MFEMProblem.C.

{
  if (parameters.getBase() == "MFEMSubMeshTransfer")
    addObject<MFEMExecutedObject>(transfer_name, name, parameters);
  else
    ExternalProblem::addTransfer(transfer_name, name, parameters);
}

addUserObject()

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

virtualinherited

Definition at line 4952 of file FEProblemBase.C.

{
#ifdef MOOSE_KOKKOS_ENABLED
  if (parameters.isKokkosObject())
  {
    addKokkosUserObject(user_object_name, name, parameters);
    return {};
  }
#endif
 
  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 FEProblemBase::addPostprocessor(), FEProblemBase::addReporter(), PhysicsBase::addUserObject(), and FEProblemBase::addVectorPostprocessor().

addVariable()

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

overridevirtual

Override of MFEMProblem::addVariable.

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

Reimplemented from MFEMProblem.

Definition at line 65 of file MFEMEigenproblem.C.

{
  validateVariableNumericType(var_type, var_name);
 
  // Reject names that would collide with the mode-suffix convention or with any
  // already-registered eigenmode storage entry.
  const auto num_modes = getParam<int>("num_modes");
  const auto & sep = getProblemData().mode_separator;
  if (getProblemData().gridfunctions.Has(var_name))
    mooseError("MFEM variable '",
               var_name,
               "' clashes with an existing gridfunction (likely an eigenmode entry from another "
               "variable). Choose a different variable name or set 'mode_separator' to a string "
               "that avoids the clash.");
 
  for (int i = 0; i < num_modes; ++i)
  {
    const auto mode_name = var_name + sep + std::to_string(i);
    if (getProblemData().gridfunctions.Has(mode_name))
      mooseError("Eigenmode storage name '",
                 mode_name,
                 "' for variable '",
                 var_name,
                 "' clashes with an already-registered variable. Set 'mode_separator' to a "
                 "string that avoids the clash, or rename the conflicting variable.");
  }
 
  addGridFunction(var_type, var_name, parameters);
 
  for (int i = 0; i < num_modes; ++i)
    addGridFunction(var_type, var_name + sep + std::to_string(i), parameters);
}

addVectorPostprocessor()

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

overridevirtualinherited

Add a vector postprocessor and register its vectors with the MFEM execution system.

Reimplemented from FEProblemBase.

Definition at line 692 of file MFEMProblem.C.

{
  if (parameters.getSystemAttributeName() == "MFEMExecutedObject")
  {
    checkUserObjectNameCollision(name, "VectorPostprocessor");
    addObject<MFEMExecutedObject>(type, name, parameters);
  }
  else
    ExternalProblem::addVectorPostprocessor(type, name, parameters);
}

addVectorTag()

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

virtualinherited

Create a Tag.

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

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

Parameters

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

Reimplemented in DisplacedProblem.

Definition at line 84 of file SubProblem.C.

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

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

addWeakForm()

void MFEMProblem::addWeakForm ( const std::string &  weak_form_name, const std::string &  name, InputParameters &  parameters  )

inherited

Add an MFEM WeakForm to the problem.

Definition at line 453 of file MFEMProblem.C.

{
  addObject<MFEMWeakFormBase>(weak_form_name, name, parameters);
}

advanceMultiApps()

void FEProblemBase::advanceMultiApps ( ExecFlagType  type )

inlineinherited

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

virtualinherited

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

Reimplemented in DumpObjectsProblem.

Definition at line 7815 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

inlineinherited

Whether to accept / allow an invalid solution.

Definition at line 2494 of file FEProblemBase.h.

{ return _allow_invalid_solution; }

Referenced by FEProblemBase::acceptInvalidSolution().

allowMeshContractionAfterMeshChanged()

virtual bool FEProblemBase::allowMeshContractionAfterMeshChanged ( ) const

inlinevirtualinherited

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

{ return true; }

Referenced by FEProblemBase::meshChanged().

allowOutput() [1/2]

void FEProblemBase::allowOutput ( bool  state )

inherited

Ability to enable/disable all output calls.

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

Definition at line 7942 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 )

inherited

Definition at line 3812 of file FEProblemBase.h.

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

appendConstantModes()

void FEProblemBase::appendConstantModes ( const std::vector< VariableName > &  vars, const std::string &  prefix, std::vector< NumericVector< libMesh::Number > * > &  sp  )

inherited

Append one mode per variable of vars in the current nonlinear system to sp.

A mode is one basis vector of a subspace. It has one entry per degree of freedom of the system. Here each mode is one on the variable's degrees of freedom and zero elsewhere. This is the coefficient vector of a constant field of the variable for a basis that is a partition of unity, such as a Lagrange or a constant monomial basis. libMesh orthonormalizes the modes before it passes them to PETSc.

Parameters

vars	The variables that each contribute one mode. Variables in other nonlinear systems are skipped.
prefix	The prefix of the name of the system vector that stores each mode
sp	The basis vectors of a subspace, such as the nullspace or the transpose nullspace of the Jacobian, that libMesh passes to PETSc

Definition at line 8938 of file FEProblemBase.C.

{
  auto & sys = _current_nl_sys->system();
  std::vector<dof_id_type> dofs;
  for (const auto & var : vars)
  {
    // Each variable lives in exactly one nonlinear system
    if (!sys.has_variable(var))
      continue;
 
    // The mode is rebuilt on every request so that it stays valid after the dof
    // distribution changes, e.g. after mesh adaptivity
    auto & mode = _current_nl_sys->addVector(prefix + var, false, libMesh::PARALLEL);
    mode.zero();
    sys.get_dof_map().local_variable_indices(dofs, sys.variable_number(var));
    for (const auto dof : dofs)
      mode.set(dof, 1);
    mode.close();
    sp.push_back(&mode);
  }
}

Referenced by FEProblemBase::computeNullSpace(), and FEProblemBase::computeTransposeNullSpace().

areCoupled()

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

inherited

Definition at line 7333 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

inlineoverridevirtualinherited

Implements SubProblem.

Definition at line 3969 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  )

inlineoverridevirtualinherited

Implements SubProblem.

Definition at line 3960 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(), NonlinearThread::onInterfaceWithHRefinementMismatch(), ComputeBoundaryInitialConditionThread::onNode(), MaxQpsThread::operator()(), FEProblemBase::reinitScalars(), and PiecewiseConstantFromCSV::value().

assemblyLevel()

mfem::AssemblyLevel MFEMProblem::assemblyLevel ( ) const

inlineinherited

Return the default assembly level to use for EquationSystem assembly.

Definition at line 432 of file MFEMProblem.h.

{ return _assembly_level; }

automaticScaling() [1/3]

bool SubProblem::automaticScaling ( ) const

inherited

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 )

virtualinherited

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 )

overridevirtualinherited

Automatic scaling setter.

Parameters

automatic_scaling

A boolean representing whether we are performing automatic scaling

Reimplemented from SubProblem.

Definition at line 10428 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 ( )

inherited

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

{
  _geometric_search_data.backup();
 
  if (_displaced_problem)
    _displaced_problem->geomSearchData().backup();
}

Referenced by FEProblemBase::advanceState().

backupMultiApps()

void FEProblemBase::backupMultiApps ( ExecFlagType  type )

inherited

Backup the MultiApps associated with the ExecFlagType.

Definition at line 6712 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  )

inherited

Definition at line 7190 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 FEProblemBase::bumpAllQRuleOrder().

bumpVolumeQRuleOrder()

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

inherited

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

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

Definition at line 7177 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 FEProblemBase::bumpVolumeQRuleOrder().

cacheJacobian()

void FEProblemBase::cacheJacobian ( const THREAD_ID  tid )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2406 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 )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2414 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 )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2277 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 )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2285 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 FEProblemBase::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 FEProblemBase::checkProblemIntegrity().

checkCoordinateSystems()

void FEProblemBase::checkCoordinateSystems ( )

protectedinherited

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

Definition at line 9994 of file FEProblemBase.C.

{
  _mesh.checkCoordinateSystems();
}

Referenced by FEProblemBase::checkProblemIntegrity().

checkDependMaterialsHelper()

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

protectedinherited

Helper method for checking Material object dependency.

See also

checkProblemIntegrity

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

Definition at line 9873 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 FEProblemBase::checkProblemIntegrity().

checkDisplacementOrders()

void FEProblemBase::checkDisplacementOrders ( )

protectedinherited

Verify that SECOND order mesh uses SECOND order displacements.

Definition at line 9788 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 FEProblemBase::checkProblemIntegrity().

checkDuplicatePostprocessorVariableNames()

void FEProblemBase::checkDuplicatePostprocessorVariableNames ( )

inherited

Definition at line 1868 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 FEProblemBase::checkProblemIntegrity().

checkExceptionAndStopSolve()

void FEProblemBase::checkExceptionAndStopSolve ( bool  print_message = true )

virtualinherited

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

Notes:

• The exception have be registered by calling setException() prior to calling this.
• This is collective on MPI, and must be called simultaneously by all processors!
• If called when the solve can be interruped, it will do so and also throw a MooseHandledException, 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 7636 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 MooseHandledException(_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(), FEProblemBase::computeUserObjects(), FEProblemBase::computeUserObjectsInternal(), FEProblemBase::handleException(), FEProblemBase::joinAndFinalize(), DisplacedProblem::updateMesh(), and DisplacedProblem::updateMesh().

checkGradientMethods()

void FEProblemBase::checkGradientMethods ( )

protectedinherited

Let every FVGradientMethod resolve its dependencies on other gradient methods.

Definition at line 9864 of file FEProblemBase.C.

{
  std::vector<FVGradientMethod *> methods;
  theWarehouse().query().condition<AttribSystem>("FVGradientMethod").queryInto(methods);
  for (auto * method : methods)
    method->resolveGradientMethodDependencies(*this);
}

Referenced by FEProblemBase::checkProblemIntegrity().

checkICRestartError()

void FEProblemBase::checkICRestartError ( const std::string &  ic_name, const std::string &  name, const VariableName &  var_name  )

privateinherited

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 3969 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 FEProblemBase::addFVInitialCondition(), and FEProblemBase::addInitialCondition().

checkingUOAuxState()

bool FEProblemBase::checkingUOAuxState ( ) const

inlineinherited

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

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

Definition at line 229 of file FEProblemBase.h.

{ return _checking_uo_aux_state; }

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

checkNonlocalCoupling()

void FEProblemBase::checkNonlocalCoupling ( )

inherited

Returns

Flag indicating nonlocal coupling exists or not.

Definition at line 2007 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

overridevirtualinherited

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

virtualinherited

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

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

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

unsigned int is necessary to print SubdomainIDs in the statement below

vector is necessary to get the subdomain names

Reimplemented in EigenProblem.

Definition at line 9614 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

inlineoverridevirtualinherited

Whether to check residual for NaN/Inf values.

Implements SubProblem.

Definition at line 232 of file FEProblemBase.h.

{ return _check_residual_for_nans; }

Referenced by DisplacedProblem::checkResidualForNans().

checkUserObjectJacobianRequirement()

void FEProblemBase::checkUserObjectJacobianRequirement ( THREAD_ID  tid )

inherited

Definition at line 2045 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

inherited

Check for name collision between different user objects.

Parameters

name	The object name being added
type	The object type being added

Definition at line 4886 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 FEProblemBase::addPostprocessor(), MFEMProblem::addPostprocessor(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), and MFEMProblem::addVectorPostprocessor().

checkUserObjects()

void FEProblemBase::checkUserObjects ( )

protectedinherited

Definition at line 9829 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 FEProblemBase::checkProblemIntegrity().

clearActiveElementalMooseVariables()

void FEProblemBase::clearActiveElementalMooseVariables ( const THREAD_ID  tid )

overridevirtualinherited

Clear the active elemental MooseVariableFEBase.

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

Parameters

tid	The thread id

Reimplemented from SubProblem.

Definition at line 7019 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 )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 7028 of file FEProblemBase.C.

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

clearActiveFEVariableCoupleableVectorTags()

void FEProblemBase::clearActiveFEVariableCoupleableVectorTags ( const THREAD_ID  tid )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 7037 of file FEProblemBase.C.

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

clearActiveMaterialProperties()

void FEProblemBase::clearActiveMaterialProperties ( const THREAD_ID  tid )

inherited

Clear the active material properties.

Should be called at the end of every computing thread

Parameters

tid	The thread id

Definition at line 7085 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 )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 7046 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 )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 7055 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 FEProblemBase::solve().

clearCurrentJacobianMatrixTags()

void FEProblemBase::clearCurrentJacobianMatrixTags ( )

inlineinherited

Clear the current Jacobian matrix tag data structure ... if someone creates it.

Definition at line 3044 of file FEProblemBase.h.

{}

Referenced by FEProblemBase::resetState().

clearCurrentResidualVectorTags()

void FEProblemBase::clearCurrentResidualVectorTags ( )

inlineinherited

Clear the current residual vector tag data structure.

Definition at line 4006 of file FEProblemBase.h.

{
  _current_residual_vector_tags.clear();
}

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

clearDiracInfo()

void FEProblemBase::clearDiracInfo ( )

overridevirtualinherited

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

Implements SubProblem.

Definition at line 2869 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  )

virtualinherited

Definition at line 8737 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  )

virtualinherited

Definition at line 9046 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 FEProblemBase::computePostCheck().

computeIndicators()

void FEProblemBase::computeIndicators ( )

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 5349 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 FEProblemBase::computeIndicatorsAndMarkers(), TransientBase::endStep(), Eigenvalue::execute(), SteadyBase::execute(), MFEMSteady::execute(), and FEProblemBase::initialAdaptMesh().

computeIndicatorsAndMarkers()

void FEProblemBase::computeIndicatorsAndMarkers ( )

virtualinherited

Definition at line 5342 of file FEProblemBase.C.

{
  computeIndicators();
  computeMarkers();
}

computeJacobian()

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

virtualinherited

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

Reimplemented in EigenProblem.

Definition at line 8562 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 FEProblemBase::computeJacobianSys().

computeJacobianBlock()

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

virtualinherited

Really not a good idea to use this.

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

Parameters

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

Definition at line 8725 of file FEProblemBase.C.

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

computeJacobianBlocks()

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

virtualinherited

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

Used by Physics-based preconditioning

Parameters

blocks

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

Reimplemented in EigenProblem.

Definition at line 8705 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 FEProblemBase::computeJacobianBlock(), and PhysicsBasedPreconditioner::setup().

computeJacobianInternal()

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

virtualinherited

Form a Jacobian matrix for multiple tags.

It should not be called directly by users.

Definition at line 8578 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 FEProblemBase::computeJacobian().

computeJacobianSys()

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

virtualinherited

Form a Jacobian matrix.

It is called by Libmesh.

Definition at line 8538 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  )

virtualinherited

Form a Jacobian matrix for a given tag.

Definition at line 8548 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 )

virtualinherited

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

Definition at line 8594 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(), FEProblemBase::computeJacobianInternal(), FEProblemBase::computeJacobianTag(), EigenProblem::computeJacobianTag(), and EigenProblem::computeMatricesTags().

computeKokkosUserObjectsInternal()

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

protectedinherited

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

computeLinearSystemSys()

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

virtualinherited

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

Parameters

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

Definition at line 8781 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 FEProblemBase::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  )

inherited

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

Parameters

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

Definition at line 8818 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 FEProblemBase::computeLinearSystemSys().

computeMarkers()

void FEProblemBase::computeMarkers ( )

virtualinherited

Reimplemented in DumpObjectsProblem.

Definition at line 5391 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 FEProblemBase::adaptMesh(), FEProblemBase::computeIndicatorsAndMarkers(), TransientBase::endStep(), Eigenvalue::execute(), SteadyBase::execute(), MFEMSteady::execute(), and FEProblemBase::initialAdaptMesh().

computeMultiAppsDT()

Real FEProblemBase::computeMultiAppsDT ( ExecFlagType  type )

inherited

Find the smallest timestep over all MultiApps.

Definition at line 6764 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  )

virtualinherited

Definition at line 8889 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  )

virtualinherited

Definition at line 8906 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()));
  }
  appendConstantModes(_constant_null_space_vars, "ConstantNullSpace_", sp);
}

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  )

virtualinherited

Definition at line 8963 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  )

virtualinherited

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  )

inherited

This function is called by Libmesh to form a residual.

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

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

computeResidualAndJacobian()

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

inherited

Form a residual and Jacobian with default tags.

Definition at line 8145 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  )

virtualinherited

Form a residual vector for a set of tags.

It should not be called directly by users.

Definition at line 8306 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 ( )

virtualinherited

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

Returns

The L2 norm of the residual

Reimplemented in EigenProblem.

Definition at line 8078 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 FEProblemBase::computeResidualL2Norm().

computeResidualL2Norm() [2/3]

Real FEProblemBase::computeResidualL2Norm ( LinearSystem &  sys )

inherited

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

Definition at line 8060 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 )

inherited

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

Definition at line 8052 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  )

virtualinherited

This function is called by Libmesh to form a residual.

Definition at line 8100 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  )

virtualinherited

Form a residual vector for a given tag.

Definition at line 8277 of file FEProblemBase.C.

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

computeResidualTags()

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

virtualinherited

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

Definition at line 8448 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(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualTag(), EigenProblem::computeResidualTag(), and FEProblemBase::computeResidualType().

computeResidualType()

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

virtualinherited

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

Definition at line 8339 of file FEProblemBase.C.

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

computeSystems()

void FEProblemBase::computeSystems ( const ExecFlagType &  type )

protectedinherited

Do generic system computations.

Definition at line 10763 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 FEProblemBase::computeBounds(), FEProblemBase::computeJacobianBlocks(), EigenProblem::computeJacobianBlocks(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), and FEProblemBase::execute().

computeTransposeNullSpace()

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

virtualinherited

Definition at line 8922 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()));
  }
  appendConstantModes(_constant_transpose_null_space_vars, "ConstantTransposeNullSpace_", sp);
}

Referenced by Moose::compute_transpose_nullspace().

computeUserObjectByName()

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

virtualinherited

Compute an user object with the given name.

Definition at line 5695 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  )

virtualinherited

Call compute methods on UserObjects.

Definition at line 5728 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 FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), and FEProblemBase::execute().

computeUserObjectsInternal()

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

protectedinherited

Definition at line 5760 of file FEProblemBase.C.

{
  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) + ")";
 
  // Each phase of process-local work below is followed by a check for an exception on any process
  // before the phase's user objects are finalized, because finalization communicates. An exception
  // stops the execution of user objects on all processes, so that none is finalized with partial
  // data
  translateUserObjectExceptions(
      [&]()
      {
        // 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());
        }
      });
  checkExceptionAndStopSolve();
 
  if (!userobjs.empty())
  {
    // 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 :-(
  if (!nodal.empty())
  {
    translateUserObjectExceptions(
        [&]()
        {
          for (auto obj : nodal)
            obj->initialize();
          ComputeNodalUserObjectsThread cnppt(*this, query);
          Threads::parallel_reduce(getCurrentAlgebraicNodeRange(), cnppt, numThreads());
        });
    checkExceptionAndStopSolve();
    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
  if (!mortar.empty())
  {
    translateUserObjectExceptions(
        [this, type, &mortar]()
        {
          for (auto obj : mortar)
            obj->initialize();
 
          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);
        });
    checkExceptionAndStopSolve();
 
    translateUserObjectExceptions(
        [&mortar]()
        {
          for (auto obj : mortar)
            obj->finalize();
        });
    checkExceptionAndStopSolve();
  }
 
  // Execute threaded general user objects
  if (!tgobjs.empty())
  {
    translateUserObjectExceptions(
        [&tgobjs]()
        {
          for (auto obj : tgobjs)
            obj->initialize();
        });
    checkExceptionAndStopSolve();
  }
  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);
 
    translateUserObjectExceptions(
        [this, &tguos]()
        {
          ComputeThreadedGeneralUserObjectsThread ctguot(*this);
 
          // Force one thread per ThreadedGeneralUserObject via grainsize
          Threads::parallel_reduce(GeneralUserObjectRange(tguos.begin(),
                                                          tguos.end(),
                                                          /*grainsize=*/1),
                                   ctguot,
                                   numThreads());
        });
    checkExceptionAndStopSolve();
    joinAndFinalize(q);
  }
 
  // Execute general user objects
  joinAndFinalize(query.clone().condition<AttribInterfaces>(Interfaces::GeneralUserObject), true);
}

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

computingNonlinearResid() [1/3]

bool SubProblem::computingNonlinearResid ( ) const

inlineinherited

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

Definition at line 718 of file SubProblem.h.

{ return _computing_nonlinear_residual; }

computingNonlinearResid() [2/3]

void FEProblemBase::computingNonlinearResid ( bool  computing_nonlinear_residual )

finalvirtualinherited

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

Reimplemented from SubProblem.

Definition at line 10394 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 )

inlinevirtualinherited

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

overridevirtualinherited

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

Returns

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

Implements SubProblem.

Definition at line 7791 of file FEProblemBase.C.

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

Referenced by DisplacedProblem::computingPreSMOResidual().

computingScalingJacobian() [1/2]

bool FEProblemBase::computingScalingJacobian ( ) const

inlinefinaloverridevirtualinherited

Getter for whether we're computing the scaling jacobian.

Implements SubProblem.

Definition at line 2929 of file FEProblemBase.h.

{ return _computing_scaling_jacobian; }

computingScalingJacobian() [2/2]

void FEProblemBase::computingScalingJacobian ( bool  computing_scaling_jacobian )

inlineinherited

Setter for whether we're computing the scaling jacobian.

Definition at line 2924 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

inlinefinaloverridevirtualinherited

Returns

whether we are currently computing a residual for automatic scaling purposes

Implements SubProblem.

Definition at line 2942 of file FEProblemBase.h.

{ return _computing_scaling_residual; }

computingScalingResidual() [2/2]

void FEProblemBase::computingScalingResidual ( bool  computing_scaling_residual )

inlineinherited

Setter for whether we're computing the scaling residual.

Definition at line 2934 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.

{ return _console; }

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

constJacobian()

bool FEProblemBase::constJacobian ( ) const

inherited

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

Definition at line 10236 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.

{ return solverSystemConverged(sys_num); }

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

coordTransform()

MooseAppCoordTransform & FEProblemBase::coordTransform ( )

inherited

Returns

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

Definition at line 10634 of file FEProblemBase.C.

{
  return mesh().coordTransform();
}

copySolutionsBackwards()

void FEProblemBase::copySolutionsBackwards ( )

virtualinherited

Definition at line 7797 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

inlineinherited

Definition at line 197 of file FEProblemBase.h.

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

inherited

Definition at line 7341 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

inlineoverridevirtualinherited

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

Implements SubProblem.

Definition at line 3978 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  )

inherited

Definition at line 9132 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  )

virtualinherited

Definition at line 7203 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 FEProblemBase::createQRules().

createTagMatrices()

void FEProblemBase::createTagMatrices ( CreateTaggedMatrixKey  )

inherited

Definition at line 842 of file FEProblemBase.C.

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

createTagSolutions()

void FEProblemBase::createTagSolutions ( )

protectedinherited

Create extra tagged solution vectors.

Definition at line 858 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 ( )

protectedinherited

Create extra tagged vectors and matrices.

Definition at line 820 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

overridevirtualinherited

Returns

the current linear system number

Implements SubProblem.

Definition at line 10651 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 ( )

inlineinherited

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

Definition at line 3946 of file FEProblemBase.h.

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

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

currentLinearSystem() [2/2]

const LinearSystem & FEProblemBase::currentLinearSystem ( ) const

inlineinherited

Get a constant reference to the current linear system.

Definition at line 3953 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.

{ return _currently_computing_jacobian; };

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

currentlyComputingResidual()

const bool & SubProblem::currentlyComputingResidual ( ) const

inlineinherited

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

Definition at line 731 of file SubProblem.h.

{ return _currently_computing_residual; }

Referenced by FEProblemBase::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().

currentNlSysNum()

unsigned int FEProblemBase::currentNlSysNum ( ) const

overridevirtualinherited

Returns

the current nonlinear system number

Implements SubProblem.

Definition at line 10640 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(), FEProblemBase::jacobianSetup(), NonlinearThread::onInterfaceWithHRefinementMismatch(), and FEProblemBase::residualSetup().

currentNonlinearSystem() [1/2]

NonlinearSystemBase & FEProblemBase::currentNonlinearSystem ( )

inlineinherited

Definition at line 3916 of file FEProblemBase.h.

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

Referenced by FEProblemBase::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

inlineinherited

Definition at line 3923 of file FEProblemBase.h.

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

currentResidualVectorTags()

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

inlineoverridevirtualinherited

Return the residual vector tags we are currently computing.

Implements SubProblem.

Definition at line 3994 of file FEProblemBase.h.

{
  return _current_residual_vector_tags;
}

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

customSetup()

void FEProblemBase::customSetup ( const ExecFlagType &  exec_type )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 5441 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 FEProblemBase::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.

{ return _default_ghosting; }

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

overrideprivatevirtualinherited

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 3316 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 FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addKernel(), FEProblemBase::addNodalKernel(), FEProblemBase::addScalarKernel(), DisplacedProblem::determineSolverSystem(), and FEProblemBase::getSystem().

diracKernelInfo()

DiracKernelInfo & SubProblem::diracKernelInfo ( )

virtualinherited

Definition at line 740 of file SubProblem.C.

{
  return _dirac_kernel_info;
}

displaceMesh()

void MFEMProblem::displaceMesh ( )

inherited

Displace the mesh, if mesh displacement is enabled.

Definition at line 768 of file MFEMProblem.C.

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

Referenced by MFEMProblemSolve::solve().

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(), FEProblemBase::meshChanged(), and VolumeAux::VolumeAux().

dt()

virtual Real & FEProblemBase::dt ( ) const

inlinevirtualinherited

Definition at line 584 of file FEProblemBase.h.

{ 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

inlinevirtualinherited

Definition at line 585 of file FEProblemBase.h.

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

protectedinherited

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

Definition at line 3179 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 FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), and FEProblemBase::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.

{ return _enabled; }

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

errorOnJacobianNonzeroReallocation()

bool FEProblemBase::errorOnJacobianNonzeroReallocation ( ) const

inlineinherited

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

Definition at line 2454 of file FEProblemBase.h.

  {
    return _error_on_jacobian_nonzero_reallocation;
  }

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::constraintJacobians(), LinearSystem::setMatrixOptions(), and NonlinearSystemBase::setMatrixOptions().

errorPrefix()

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

inlineinherited

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

Definition at line 264 of file MooseBase.h.

{ return messagePrefix(); }

es()

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

inlineoverridevirtualinherited

Implements SubProblem.

Definition at line 181 of file FEProblemBase.h.

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

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

execMultiApps()

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

inherited

Execute the MultiApps associated with the ExecFlagType.

Definition at line 6547 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 FEProblemBase::adaptMesh(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::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 = ""  )

inherited

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 6300 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 FEProblemBase::execMultiApps().

execute()

void MFEMProblem::execute ( const ExecFlagType &  exec_type )

overridevirtualinherited

Convenience function for performing execution of MOOSE systems.

Reimplemented from FEProblemBase.

Definition at line 100 of file MFEMProblem.C.

{
  setCurrentExecuteOnFlag(exec_type);
  executeMFEMObjects(exec_type);
 
  ExternalProblem::execute(exec_type);
}

Referenced by MFEMSteady::execute(), and MFEMSteady::init().

executeAllObjects()

void FEProblemBase::executeAllObjects ( const ExecFlagType &  exec_type )

virtualinherited

Definition at line 5436 of file FEProblemBase.C.

{
}

Referenced by Executor::exec().

executeControls()

void FEProblemBase::executeControls ( const ExecFlagType &  exec_type )

inherited

Performs setup and execute calls for Control objects.

Definition at line 5985 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 FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::execute(), and FixedPointSolve::solveStep().

executeMFEMObjects()

void MFEMProblem::executeMFEMObjects ( const ExecFlagType &  exec_type )

inherited

Execute MFEM executed objects scheduled on the supplied execute flag.

Definition at line 860 of file MFEMProblem.C.

{
  std::vector<MFEMExecutedObject *> objects;
  theWarehouse()
      .query()
      .condition<AttribSystem>("MFEMExecutedObject")
      .condition<AttribExecOns>(exec_type)
      .condition<AttribThread>(0)
      .queryInto(objects);
 
  std::map<std::string, const MFEMExecutedObject *> suppliers;
  for (auto * const object : objects)
    for (const auto & item : object->getSuppliedItems())
    {
      const auto [it, inserted] = suppliers.emplace(item, object);
      if (!inserted && it->second != object)
        mooseError("MFEM executed-object dependency ambiguity on ",
                   exec_type,
                   ": both '",
                   it->second->name(),
                   "' and '",
                   object->name(),
                   "' supply '",
                   item,
                   "'.");
    }
 
  for (auto * const object : objects)
  {
    object->initialize();
    object->execute();
    object->finalize();
 
    if (auto * const pp = dynamic_cast<const Postprocessor *>(object))
    {
      _reporter_data.finalize(pp->PPName());
      setPostprocessorValueByName(pp->PPName(), pp->getValue());
    }
 
    if (auto * const vpp = dynamic_cast<VectorPostprocessor *>(object))
      _reporter_data.finalize(vpp->PPName());
  }
}

Referenced by MFEMProblem::execute().

executeSamplers()

void FEProblemBase::executeSamplers ( const ExecFlagType &  exec_type )

inherited

Performs setup and execute calls for Sampler objects.

Definition at line 6033 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 FEProblemBase::execute().

externalSolve()

virtual void MFEMProblem::externalSolve ( )

inlineoverridevirtualinherited

New interface for solving an External problem.

"solve()" is finalized here to provide callbacks for solution syncing.

Implements ExternalProblem.

Definition at line 51 of file MFEMProblem.h.

{}

feBackend()

Moose::FEBackend MFEMProblem::feBackend ( ) const

inlineoverridevirtualinherited

Reimplemented from FEProblemBase.

Definition at line 362 of file MFEMProblem.h.

{ return Moose::FEBackend::MFEM; }

fieldScalarCouplingEntries()

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

inherited

Definition at line 7353 of file FEProblemBase.C.

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

finalizeMultiApps()

void FEProblemBase::finalizeMultiApps ( )

inherited

Definition at line 6662 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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 7785 of file FEProblemBase.C.

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

finishMultiAppStep()

void FEProblemBase::finishMultiAppStep ( ExecFlagType  type, bool  recurse_through_multiapp_levels = false  )

inherited

Finish the MultiApp time step (endStep, postStep) associated with the ExecFlagType.

Optionally recurse through all multi-app levels

Definition at line 6690 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 FEProblemBase::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 ( )

inherited

Indicates that the next call to outputStep should be forced.

This is needed by the MultiApp system, if forceOutput is called the next call to outputStep, regardless of the type supplied to the call, will be executed with EXEC_FORCED.

Forced output will NOT override the allowOutput flag.

Definition at line 7948 of file FEProblemBase.C.

{
  _app.getOutputWarehouse().forceOutput();
}

Referenced by TransientMultiApp::solveStep().

fvBCsIntegrityCheck() [1/2]

bool FEProblemBase::fvBCsIntegrityCheck ( ) const

inlineinherited

Returns

whether to perform a boundary condition integrity check for finite volume

Definition at line 2844 of file FEProblemBase.h.

{ return _fv_bcs_integrity_check; }

fvBCsIntegrityCheck() [2/2]

void FEProblemBase::fvBCsIntegrityCheck ( bool  fv_bcs_integrity_check )

inlineinherited

Parameters

fv_bcs_integrity_check

Whether to perform a boundary condition integrity check for finite volume

Definition at line 3984 of file FEProblemBase.h.

{
  if (!_fv_bcs_integrity_check)
    // the user has requested that we don't check integrity so we will honor that
    return;
 
  _fv_bcs_integrity_check = fv_bcs_integrity_check;
}

geomSearchData()

virtual GeometricSearchData & FEProblemBase::geomSearchData ( )

inlineoverridevirtualinherited

Implements SubProblem.

Definition at line 2116 of file FEProblemBase.h.

{ 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(), FEProblemBase::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  )

overridevirtualinherited

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

Implements SubProblem.

Definition at line 6893 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  )

overridevirtualinherited

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

Implements SubProblem.

Definition at line 6917 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 ( )

inlineinherited

Definition at line 1094 of file FEProblemBase.h.

{ 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(), FEProblemBase::execute(), ActivateElementsUserObjectBase::initSolutions(), EigenExecutionerBase::inversePowerIteration(), PNGOutput::makeMeshFunc(), MoveNodesByParsedExpressionModifier::MoveNodesByParsedExpressionModifier(), MultiAppVariableValueSamplePostprocessorTransfer::MultiAppVariableValueSamplePostprocessorTransfer(), NonlinearThread::onInterfaceWithHRefinementMismatch(), 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().

getAuxVariableNames()

std::vector< VariableName > MFEMProblem::getAuxVariableNames ( )

virtualinherited

Returns all the variable names from the auxiliary system base.

This is helpful in the syncSolutions() method when transferring variable data.

Definition at line 810 of file MFEMProblem.C.

{
  return systemBaseAuxiliary().getVariableNames();
}

getAxisymmetricRadialCoord()

unsigned int SubProblem::getAxisymmetricRadialCoord ( ) const

inherited

Returns the desired radial direction for RZ coordinate transformation.

Returns

The coordinate direction for the radial direction

Definition at line 788 of file SubProblem.C.

{
  return mesh().getAxisymmetricRadialCoord();
}

getBase()

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

inlineinherited

Returns

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

Definition at line 147 of file MooseBase.h.

{ return _pars.getBase(); }

Referenced by MooseBase::uniqueParameterName().

getBndMaterialPropertyStorage()

const MaterialPropertyStorage & FEProblemBase::getBndMaterialPropertyStorage ( )

inlineinherited

Definition at line 2138 of file FEProblemBase.h.

{ return _bnd_material_props; }

getCheckedPointerParam()

template<typename T >

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

inherited

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

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

Definition at line 450 of file MooseBase.h.

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

getCoefficients()

Moose::MFEM::CoefficientManager & MFEMProblem::getCoefficients ( )

inlineinherited

Method to get the PropertyManager object for storing material properties and converting them to MFEM coefficients.

This is used by Material and Kernel classes (among others).

Definition at line 315 of file MFEMProblem.h.

{ return _problem_data.coefficients; }

Referenced by MFEMProblem::addFunction(), MFEMProblem::addPostprocessor(), MFEMComplexVariable::declareCoefficients(), MFEMVariable::declareCoefficients(), MFEMCoordinateTransformations::declareRZCoefficients(), MFEMObject::getMatrixCoefficientByName(), getRHSCoefficient(), MFEMObject::getScalarCoefficientByName(), MFEMObject::getVectorCoefficientByName(), MFEMParsedFunction::initialSetup(), MFEMScalarQuadratureFunction::initialSetup(), MFEMVectorQuadratureFunction::initialSetup(), MFEMScalarQuadratureFunction::MFEMScalarQuadratureFunction(), and MFEMVectorQuadratureFunction::MFEMVectorQuadratureFunction().

getComm()

MPI_Comm MFEMProblem::getComm ( )

inlineinherited

Return the MPI communicator associated with this FE problem's mesh.

Definition at line 331 of file MFEMProblem.h.

{ return getProblemData().comm; }

getComplexGridFunction()

std::shared_ptr< mfem::ParComplexGridFunction > MFEMProblem::getComplexGridFunction ( const std::string &  name )

inlineinherited

Returns

a shared pointer to an MFEM parallel complex grid function

Definition at line 397 of file MFEMProblem.h.

  {
    return _problem_data.cmplx_gridfunctions.GetShared(name);
  }

Referenced by MFEMComplexScalarBoundaryIC::execute(), MFEMComplexScalarIC::execute(), MFEMComplexVectorIC::execute(), MFEMComplexSumAux::MFEMComplexSumAux(), MFEMComplexVariableValueSamplerBase::MFEMComplexVariableValueSamplerBase(), MultiAppMFEMCopyTransfer::transferVariables(), and MultiAppMFEMShapeEvaluationTransfer::transferVariables().

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

inlineinherited

Reference to the control logic warehouse.

Definition at line 2636 of file FEProblemBase.h.

{ return _control_warehouse; }

Referenced by LibtorchControlValuePostprocessor::initialSetup(), and LibtorchArtificialNeuralNetParameters::initialSetup().

getConvergence()

Convergence & FEProblemBase::getConvergence ( const std::string &  name, const THREAD_ID  tid = 0  ) const

virtualinherited

Gets a Convergence object.

Definition at line 3042 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

virtualinherited

Gets the Convergence objects.

Definition at line 3052 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 ( )

inherited

Definition at line 10792 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(), FEProblemBase::projectSolution(), and NonlinearSystemBase::setInitialSolution().

getCurrentAlgebraicElementRange()

const ConstElemRange & FEProblemBase::getCurrentAlgebraicElementRange ( )

inherited

These are the element and nodes that contribute to the jacobian and residual for this local processor.

getCurrentAlgebraicElementRange() returns the element range that contributes to the system getCurrentAlgebraicNodeRange() returns the node range that contributes to the system getCurrentAlgebraicBndNodeRange returns the boundary node ranges that contributes to the system

Definition at line 10776 of file FEProblemBase.C.

{
  if (!_current_algebraic_elem_range)
    return *_mesh.getActiveLocalElementRange();
 
  return *_current_algebraic_elem_range;
}

Referenced by NonlinearSystemBase::computeDamping(), FEProblemBase::computeIndicators(), NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), FEProblemBase::computeMarkers(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeScaling(), FEProblemBase::computeUserObjectsInternal(), FEProblemBase::projectSolution(), and FEProblemBase::updateMaxQps().

getCurrentAlgebraicNodeRange()

const ConstNodeRange & FEProblemBase::getCurrentAlgebraicNodeRange ( )

inherited

Definition at line 10784 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 FEProblemBase::computeUserObjectsInternal().

getCurrentExecuteOnFlag()

const ExecFlagType & FEProblemBase::getCurrentExecuteOnFlag ( ) const

inherited

Return/set the current execution flag.

Returns EXEC_NONE when not being executed.

See also

FEProblemBase::execute

Definition at line 5424 of file FEProblemBase.C.

{
  return _current_execute_on_flag;
}

Referenced by MultiAppGeneralFieldTransfer::acceptPointInOriginMesh(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), MultiAppGeneralFieldTransfer::closestToPosition(), MultiAppGeneralFieldKDTreeTransferBase::computeNumSources(), NearestPositionsDivision::divisionIndex(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), NearestPositionsDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), PIDTransientControl::execute(), Terminator::execute(), PositionsFunctorValueSampler::execute(), Control::getControllableParameterByName(), Material::getMaterialByName(), MultiAppGeneralFieldKDTreeTransferBase::getNumDivisions(), NumPositions::getValue(), DistributedPositions::initialize(), ParsedDownSelectionPositions::initialize(), TransformedPositions::initialize(), PositionsFunctorValueSampler::initialize(), MultiAppGeneralFieldTransfer::locatePointReceivers(), ComputeUserObjectsThread::printBlockExecutionInformation(), ComputeFVInitialConditionThread::printGeneralExecutionInformation(), ComputeInitialConditionThread::printGeneralExecutionInformation(), ComputeLinearFVElementalThread::printGeneralExecutionInformation(), ComputeLinearFVFaceThread::printGeneralExecutionInformation(), ComputeDiracThread::printGeneralExecutionInformation(), ComputeElemDampingThread::printGeneralExecutionInformation(), ComputeIndicatorThread::printGeneralExecutionInformation(), ComputeMarkerThread::printGeneralExecutionInformation(), ComputeNodalDampingThread::printGeneralExecutionInformation(), ComputeNodalKernelBCJacobiansThread::printGeneralExecutionInformation(), ComputeNodalKernelBcsThread::printGeneralExecutionInformation(), ComputeNodalKernelJacobiansThread::printGeneralExecutionInformation(), ComputeNodalKernelsThread::printGeneralExecutionInformation(), ComputeNodalUserObjectsThread::printGeneralExecutionInformation(), ComputeUserObjectsThread::printGeneralExecutionInformation(), NonlinearThread::printGeneralExecutionInformation(), ComputeThreadedGeneralUserObjectsThread::printGeneralExecutionInformation(), MultiApp::restore(), SolutionInvalidityOutput::shouldOutput(), ElementReporter::shouldStore(), GeneralReporter::shouldStore(), and NodalReporter::shouldStore().

getCurrentICState()

unsigned short FEProblemBase::getCurrentICState ( )

inherited

Retrieves the current initial condition state.

Returns

current initial condition state

Definition at line 10835 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 )

overridevirtualinherited

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

Implements SubProblem.

Definition at line 2850 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

inlineinherited

Definition at line 2394 of file FEProblemBase.h.

{ return _discrete_materials; }

getDisplacedProblem() [1/2]

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

inlinevirtualinherited

Definition at line 2072 of file FEProblemBase.h.

{ return _displaced_problem; }

getDisplacedProblem() [2/2]

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

inlinevirtualinherited

Definition at line 2068 of file FEProblemBase.h.

  {
    return _displaced_problem;
  }

Referenced by MooseApp::attachRelationshipManagers(), NonlinearSystemBase::augmentSparsity(), NonlinearSystemBase::computeJacobianInternal(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::computeScaling(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), MultiApp::createApp(), DMMooseGetEmbedding_Private(), DMSetUp_Moose_Pre(), ActivateElementsUserObjectBase::execute(), MultiAppUserObjectTransfer::execute(), ActivateElementsUserObjectBase::finalize(), RadialAverage::finalize(), MultiApp::getBoundingBox(), MultiAppFieldTransfer::getEquationSystem(), MFEMMultiAppTransfer::getlibMeshEquationSystem(), EqualValueBoundaryConstraint::ghostPrimary(), Exodus::handleExodusIOMeshRenumbering(), EigenExecutionerBase::init(), Adaptivity::init(), NonlinearSystemBase::initialSetup(), EigenExecutionerBase::inversePowerIteration(), NonlinearThread::onInterfaceWithHRefinementMismatch(), Output::Output(), Exodus::outputSetup(), NonlinearSystemBase::overwriteNodeFace(), NonlinearSystemBase::reinitNodeFace(), NonlinearSystemBase::setConstraintSecondaryValues(), NonlinearSystemBase::setInitialSolution(), ActivateElementsUserObjectBase::setNewBoundayName(), and Moose::PeriodicBCHelper::setupPeriodicBoundaries().

getDistribution()

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

virtualinherited

Definition at line 3124 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().

getEquationSystem()

std::shared_ptr< Moose::MFEM::EquationSystem > MFEMProblem::getEquationSystem ( const std::string &  weak_form_name = "" ) const

inherited

Return the EquationSystem built by the weak form named weak_form_name.

If the name is empty, return the problem's sole EquationSystem; it is an error to omit the name when more than one weak form has been added, since the choice would otherwise be silently arbitrary.

Definition at line 494 of file MFEMProblem.C.

{
  const auto & eqn_systems = getProblemData().eqn_systems;
 
  if (!weak_form_name.empty())
    return eqn_systems.GetShared(weak_form_name);
 
  mooseAssert(eqn_systems.size() != 0, "No equation systems have been built for this problem");
 
  if (eqn_systems.size() > 1)
    mooseError("This problem has ",
               eqn_systems.size(),
               " equation systems, so the one to use cannot be inferred. Set the 'weak_form' "
               "parameter to name the weak form whose equation system should be used.");
 
  return eqn_systems.begin()->second;
}

Referenced by Moose::MFEM::EigenproblemESProblemOperator::EigenproblemESProblemOperator(), and Moose::MFEM::LinearSolverBase::LinearSolverBase().

getEvaluableElementRange()

const ConstElemRange & FEProblemBase::getEvaluableElementRange ( )

inherited

In general, {evaluable elements} >= {local elements} U {algebraic ghosting elements}.

That is, the number of evaluable elements does NOT necessarily equal to the number of local and algebraic ghosting elements. For example, if using a Lagrange basis for all variables, if a non-local, non-algebraically-ghosted element is surrounded by neighbors which are local or algebraically ghosted, then all the nodal (Lagrange) degrees of freedom associated with the non-local, non-algebraically-ghosted element will be evaluable, and hence that element will be considered evaluable.

getNonlinearEvaluableElementRange() returns the evaluable element range based on the nonlinear system dofmap; getAuxliaryEvaluableElementRange() returns the evaluable element range based on the auxiliary system dofmap; getEvaluableElementRange() returns the element range that is evaluable based on both the nonlinear dofmap and the auxliary dofmap.

Definition at line 1008 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 )

inlinevirtualinherited

Definition at line 2526 of file FEProblemBase.h.

{ return _app.getExecutor(name); }

getFailNextNonlinearConvergenceCheck()

bool FEProblemBase::getFailNextNonlinearConvergenceCheck ( ) const

inlineinherited

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

Definition at line 2985 of file FEProblemBase.h.

{ return getFailNextSystemConvergenceCheck(); }

Referenced by NonlinearSystemBase::computeScaling(), NonlinearSystem::converged(), Moose::PetscSupport::petscNonlinearConverged(), and ComputeResidualFunctor::residual().

getFailNextSystemConvergenceCheck()

bool FEProblemBase::getFailNextSystemConvergenceCheck ( ) const

inlineinherited

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

Definition at line 2987 of file FEProblemBase.h.

{ return _fail_next_system_convergence_check; }

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

getFunction()

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

virtualinherited

Definition at line 2984 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 ( )

inlineinherited

Definition at line 2383 of file FEProblemBase.h.

{ 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

inherited

Retrieve an advected interpolation method.

Parameters

name	The name of the method.
tid	The thread ID.

Definition at line 5204 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

inherited

Retrieve a scalar face interpolation method.

Parameters

name	The name of the method.
tid	The thread ID.

Definition at line 5187 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  )

inherited

Retrieve a writable FV gradient method owned by this problem.

Parameters

name	The name of the method.
tid	The thread ID.

Definition at line 5140 of file FEProblemBase.C.

{
  return const_cast<FVGradientMethod &>(
      static_cast<const FEProblemBase &>(*this).getFVGradientMethod(name, tid));
}

Referenced by FEProblemBase::getFVGradientMethod().

getFVGradientMethod() [2/2]

const FVGradientMethod & FEProblemBase::getFVGradientMethod ( const GradientMethodName &  name, const THREAD_ID  tid = 0  ) const

inherited

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

inlineinherited

Return FVInitialCondition storage.

Definition at line 2180 of file FEProblemBase.h.

{ 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

inherited

Retrieve an FV interpolation method.

Parameters

name	The name of the method.
tid	The thread ID.

Definition at line 5160 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 FEProblemBase::getFVAdvectedInterpolationMethod(), and FEProblemBase::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  )

inherited

Get the materials and variables potentially needed for FV.

Parameters

block_id	SubdomainID The subdomain id that we want to retrieve materials for
face_materials	The face materials container that we will fill
neighbor_materials	The neighbor materials container that we will fill
variables	The variables container that we will fill that our materials depend on
tid	The thread id

Definition at line 10467 of file FEProblemBase.C.

{
  if (_materials[Moose::FACE_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
  {
    auto & this_face_mats =
        _materials[Moose::FACE_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid);
    for (std::shared_ptr<MaterialBase> face_mat : this_face_mats)
      if (face_mat->ghostable())
      {
        face_materials.push_back(face_mat);
        auto & var_deps = face_mat->getMooseVariableDependencies();
        for (auto * var : var_deps)
        {
          if (!var->isFV())
            mooseError(
                "Ghostable materials should only have finite volume variables coupled into them.");
          else if (face_mat->hasStatefulProperties())
            mooseError("Finite volume materials do not currently support stateful properties.");
          variables.insert(var);
        }
      }
  }
 
  if (_materials[Moose::NEIGHBOR_MATERIAL_DATA].hasActiveBlockObjects(blk_id, tid))
  {
    auto & this_neighbor_mats =
        _materials[Moose::NEIGHBOR_MATERIAL_DATA].getActiveBlockObjects(blk_id, tid);
    for (std::shared_ptr<MaterialBase> neighbor_mat : this_neighbor_mats)
      if (neighbor_mat->ghostable())
      {
        neighbor_materials.push_back(neighbor_mat);
#ifndef NDEBUG
        auto & var_deps = neighbor_mat->getMooseVariableDependencies();
        for (auto * var : var_deps)
        {
          if (!var->isFV())
            mooseError(
                "Ghostable materials should only have finite volume variables coupled into them.");
          else if (neighbor_mat->hasStatefulProperties())
            mooseError("Finite volume materials do not currently support stateful properties.");
          auto pr = variables.insert(var);
          mooseAssert(!pr.second,
                      "We should not have inserted any new variables dependencies from our "
                      "neighbor materials that didn't exist for our face materials");
        }
#endif
      }
  }
}

getGridFunction()

std::shared_ptr< mfem::ParGridFunction > MFEMProblem::getGridFunction ( const std::string &  name )

inlineinherited

Returns

a shared pointer to an MFEM parallel grid function

Definition at line 389 of file MFEMProblem.h.

  {
    return _problem_data.gridfunctions.GetShared(name);
  }

Referenced by MFEML2ZienkiewiczZhuIndicator::createEstimator(), MFEMScalarBoundaryIC::execute(), MFEMScalarIC::execute(), MFEMVectorIC::execute(), MFEMProblem::getMeshDisplacementGridFunction(), MFEMSumAux::MFEMSumAux(), MFEMVariableValueSamplerBase::MFEMVariableValueSamplerBase(), MultiApplibMeshToMFEMShapeEvaluationTransfer::transferVariables(), MultiAppMFEMCopyTransfer::transferVariables(), MultiAppMFEMShapeEvaluationTransfer::transferVariables(), and MultiAppMFEMTolibMeshShapeEvaluationTransfer::transferVariables().

getHitNode() [1/2]

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

inlineinherited

Returns

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

Definition at line 136 of file MooseBase.h.

{ return getHitNode(_pars); }

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

getHitNode() [2/2]

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

staticprivateinherited

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

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

Definition at line 167 of file MooseBase.C.

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

getIndicatorWarehouse()

const MooseObjectWarehouse< Indicator > & FEProblemBase::getIndicatorWarehouse ( )

inlineinherited

Return indicator/marker storage.

Definition at line 2164 of file FEProblemBase.h.

{ return _indicators; }

getInitialConditionWarehouse()

const InitialConditionWarehouse & FEProblemBase::getInitialConditionWarehouse ( ) const

inlineinherited

Return InitialCondition storage.

Definition at line 2175 of file FEProblemBase.h.

{ return _ics; }

Referenced by ComputeBoundaryInitialConditionThread::onNode(), ComputeInitialConditionThread::operator()(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), and ComputeInitialConditionThread::printGeneralExecutionInformation().

getInterfaceMaterialsWarehouse()

const MaterialWarehouse & FEProblemBase::getInterfaceMaterialsWarehouse ( ) const

inlineinherited

Definition at line 2395 of file FEProblemBase.h.

{ return _interface_materials; }

Referenced by SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), and ComputeUserObjectsThread::getInterfaceMaterialReinitCache().

getInternalSideIndicatorWarehouse()

const MooseObjectWarehouse< InternalSideIndicatorBase > & FEProblemBase::getInternalSideIndicatorWarehouse ( )

inlineinherited

Definition at line 2165 of file FEProblemBase.h.

  {
    return _internal_side_indicators;
  }

getKokkosBndMaterialPropertyStorage()

Moose::Kokkos::MaterialPropertyStorage & FEProblemBase::getKokkosBndMaterialPropertyStorage ( )

inlineinherited

Definition at line 2149 of file FEProblemBase.h.

  {
    return _kokkos_bnd_material_props;
  }

getKokkosFESystem() [1/2]

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

inherited

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

inherited

getKokkosFESystems() [1/2]

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

inlineinherited

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

inlineinherited

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 )

virtualinherited

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 )

inherited

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

inherited

Returns

The Kokkos MaterialData for the type type for thread tid

Referenced by BlockRestrictable::initializeBlockRestrictable().

getKokkosMaterialPropertyStorage()

Moose::Kokkos::MaterialPropertyStorage & FEProblemBase::getKokkosMaterialPropertyStorage ( )

inlineinherited

Definition at line 2145 of file FEProblemBase.h.

  {
    return _kokkos_material_props;
  }

getKokkosMaterialPropertyStorageConsumers()

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

inherited

Returns

The consumers of the Kokkos MaterialPropertyStorage for the type type

getKokkosMaterialsWarehouse()

const MaterialWarehouse & FEProblemBase::getKokkosMaterialsWarehouse ( ) const

inlineinherited

Definition at line 2401 of file FEProblemBase.h.

{ return _kokkos_materials; }

getKokkosNeighborMaterialPropertyStorage()

Moose::Kokkos::MaterialPropertyStorage & FEProblemBase::getKokkosNeighborMaterialPropertyStorage ( )

inlineinherited

Definition at line 2153 of file FEProblemBase.h.

  {
    return _kokkos_neighbor_material_props;
  }

getKokkosSystem() [1/2]

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

inherited

Get the Kokkos System of a specified number.

Parameters

sys_num

The system number

Returns

The Kokkos System

getKokkosSystem() [2/2]

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

inherited

getKokkosSystems() [1/2]

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

inlineinherited

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

{ return _kokkos_systems; }

getKokkosSystems() [2/2]

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

inlineinherited

Definition at line 893 of file FEProblemBase.h.

  {
    return _kokkos_systems;
  }

getKokkosUserObject()

template<class T >

const T & FEProblemBase::getKokkosUserObject ( const std::string &  name ) const

inlineinherited

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

inherited

Gets the linear convergence object name(s).

Definition at line 10580 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 )

inlineinherited

Get non-constant reference to a linear system.

Parameters

sys_num

The number of the linear system

Definition at line 3930 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

inlineinherited

Get a constant reference to a linear system.

Parameters

sys_num

The number of the linear system

Definition at line 3938 of file FEProblemBase.h.

{
  mooseAssert(sys_num < _linear_systems.size(),
              "System number greater than the number of linear systems");
  return *_linear_systems[sys_num];
}

getLinearSystemNames()

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

inlineinherited

Returns

the linear system names in the problem

Definition at line 3066 of file FEProblemBase.h.

{ return _linear_sys_names; }

Referenced by PhysicsBase::initializePhysics(), and MultiSystemSolveObject::MultiSystemSolveObject().

getLineSearch()

LineSearch * FEProblemBase::getLineSearch ( )

inlineoverridevirtualinherited

getter for the MOOSE line search

Implements SubProblem.

Definition at line 851 of file FEProblemBase.h.

{ return _line_search.get(); }

Referenced by DisplacedProblem::getLineSearch().

getMarkerWarehouse()

const MooseObjectWarehouse< Marker > & FEProblemBase::getMarkerWarehouse ( )

inlineinherited

Definition at line 2169 of file FEProblemBase.h.

{ return _markers; }

getMaterial()

std::shared_ptr< MaterialBase > FEProblemBase::getMaterial ( std::string  name, Moose::MaterialDataType  type, const THREAD_ID  tid = 0, bool  no_warn = false  )

inherited

Return a pointer to a MaterialBase object.

If no_warn is true, suppress warning about retrieving a material reference potentially during the material's calculation.

This will return enabled or disabled objects, the main purpose is for iterative materials.

Definition at line 4290 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

inherited

Returns

The MaterialData for the type type for thread tid

Definition at line 4319 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 FEProblemBase::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

inlineinherited

Returns

A reference to the material property registry

Definition at line 2127 of file FEProblemBase.h.

  {
    return _material_prop_registry;
  }

Referenced by DiffusionCG::addFEKernels(), SideUserObject::checkNoInterfaceMaterialPropertyDependencies(), and MaterialBase::checkStatefulSanity().

getMaterialPropertyStorage()

const MaterialPropertyStorage & FEProblemBase::getMaterialPropertyStorage ( )

inlineinherited

Return a reference to the material property storage.

Returns

A const reference to the material property storage

Definition at line 2137 of file FEProblemBase.h.

{ return _material_props; }

getMaterialPropertyStorageConsumers()

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

inherited

Returns

The consumers of the MaterialPropertyStorage for the type type

Definition at line 4345 of file FEProblemBase.C.

{
  switch (type)
  {
    case Moose::BLOCK_MATERIAL_DATA:
      return _material_props.getConsumers(type);
    case Moose::NEIGHBOR_MATERIAL_DATA:
      return _neighbor_material_props.getConsumers(type);
    case Moose::BOUNDARY_MATERIAL_DATA:
    case Moose::FACE_MATERIAL_DATA:
    case Moose::INTERFACE_MATERIAL_DATA:
      return _bnd_material_props.getConsumers(type);
  }
 
  mooseError("FEProblemBase::getMaterialPropertyStorageConsumers(): Invalid MaterialDataType ",
             type);
}

getMaterialWarehouse()

const MaterialWarehouse & FEProblemBase::getMaterialWarehouse ( ) const

inlineinherited

Definition at line 2388 of file FEProblemBase.h.

{ return _all_materials; }

Referenced by MaterialPropertyInterface::buildRequiredMaterials(), BlockRestrictable::hasBlockMaterialPropertyHelper(), BoundaryRestrictable::hasBoundaryMaterialPropertyHelper(), ArrayDGDiffusion::initialSetup(), ADArrayReaction::initialSetup(), ArrayDiffusion::initialSetup(), ArrayReaction::initialSetup(), ArrayTimeDerivative::initialSetup(), ElementSubdomainModifierBase::modify(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), MaterialPropertyDebugOutput::printMaterialMap(), ComputeIndicatorThread::subdomainChanged(), ComputeUserObjectsThread::subdomainChanged(), and NonlinearThread::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(), TimeIntegrator::requestTimeJacobian(), 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.

{ return _matrix_tag_name_to_tag_id; }

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

getMaxQps()

unsigned int FEProblemBase::getMaxQps ( ) const

inherited

Returns

The maximum number of quadrature points in use on any element in this problem.

Definition at line 1993 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(), FEProblemBase::reinitDirac(), Material::subdomainSetup(), and FEProblemBase::updateMaxQps().

getMaxScalarOrder()

Order FEProblemBase::getMaxScalarOrder ( ) const

inherited

Returns

The maximum order for all scalar variables in this problem's systems.

Definition at line 2001 of file FEProblemBase.C.

{
  return _max_scalar_order;
}

Referenced by ScalarCoupleable::coupledScalarOrder(), ScalarCoupleable::getADDefaultValue(), and ScalarCoupleable::getDefaultValue().

getMeshDisplacementGridFunction()

const mfem::ParGridFunction & MFEMProblem::getMeshDisplacementGridFunction ( )

inherited

Returns reference to the displacement GridFunction to apply to nodes.

Definition at line 779 of file MFEMProblem.C.

{
  return *getGridFunction(mesh().getMeshDisplacementVariable());
}

Referenced by MFEMProblem::displaceMesh().

getMeshDivision()

MeshDivision & FEProblemBase::getMeshDivision ( const std::string &  name, const THREAD_ID  tid = 0  ) const

inherited

Get a MeshDivision.

Definition at line 3073 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().

getMFEMObject()

template<typename T >

T & MFEMProblem::getMFEMObject ( const std::string &  system, const std::string &  name, const THREAD_ID  tid = 0  ) const

inherited

Retrieve an MFEM object from the warehouse by system and name.

Definition at line 495 of file MFEMProblem.h.

{
  std::vector<T *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>(system)
      .condition<AttribThread>(tid)
      .condition<AttribName>(name)
      .queryInto(objs);
  if (objs.empty())
    mooseError("Unable to find MFEM object with system '" + system + "' and name '" + name + "'");
  mooseAssert(objs.size() == 1, "Shouldn't find more than one object with given system and name");
  return *(objs[0]);
}

Referenced by MFEMFESpaceHierarchy::buildHierarchy(), MFEML2ZienkiewiczZhuIndicator::createEstimator(), MFEML2ZienkiewiczZhuIndicator::MFEML2ZienkiewiczZhuIndicator(), MFEMRefinementMarker::MFEMRefinementMarker(), MFEMVariable::MFEMVariable(), and Moose::MFEM::LinearSolverBase::SetPreconditioner().

getMFEMVariableMesh()

const mfem::ParMesh & MFEMProblem::getMFEMVariableMesh ( std::string  var_name )

inlineinherited

Return the ParMesh associated with a particular variable.

Definition at line 336 of file MFEMProblem.h.

  {
    if (_problem_data.gridfunctions.Has(var_name))
      return *_problem_data.gridfunctions.Get(var_name)->ParFESpace()->GetParMesh();
    else if (_problem_data.cmplx_gridfunctions.Has(var_name))
      return *_problem_data.cmplx_gridfunctions.Get(var_name)->ParFESpace()->GetParMesh();
    else
      mooseError("Variable " + var_name +
                 " not found in MFEMProblem real or complex gridfunctions.");
  }

getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

{ return _app; }

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), MooseMesh::cacheChangedLists(), ReporterTransferInterface::checkHasReporterValue(), LinearFVGradientManager::checkRestartedGradientHistory(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Coupleable::Coupleable(), MortarInterfaceWarehouse::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), GreaterThanLessThanPostprocessor::execute(), Terminator::execute(), WorkBalance::execute(), FEProblemSolve::FEProblemSolve(), RadialAverage::finalize(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), FEProblemBase::getDistribution(), FEProblemBase::getFunction(), FEProblemBase::getFVInterpolationMethod(), FEProblemBase::getMultiApp(), FEProblemBase::getSampler(), DefaultConvergenceBase::getSharedExecutionerParam(), FEProblemBase::getUserObjectBase(), FEProblemBase::getVectorPostprocessorObjectByName(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseLinearVariableFV< OutputType >::MooseLinearVariableFV(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), 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  )

inherited

Definition at line 9186 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

inherited

Return the undisplaced or displaced mortar generation object associated with the provided boundaries and subdomains.

Definition at line 9176 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

inherited

Definition at line 10868 of file FEProblemBase.C.

{
  return _mortar_data->getMortarInterfaces(on_displaced);
}

Referenced by FEProblemBase::computeUserObjectsInternal(), MortarSegmentMeshReporter::execute(), and NonlinearSystemBase::initialSetup().

getMortarUserObjects() [1/2]

std::vector< MortarUserObject * > FEProblemBase::getMortarUserObjects ( BoundaryID  primary_boundary_id, BoundaryID  secondary_boundary_id, bool  displaced  )

privateinherited

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

privateinherited

Helper for getting mortar objects corresponding to primary boundary ID, secondary boundary ID, and displaced parameters, given some initial set.

Definition at line 10676 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 FEProblemBase::computeUserObjectsInternal(), FEProblemBase::getMortarUserObjects(), and FEProblemBase::reinitMortarUserObjects().

getMultiApp()

std::shared_ptr< MultiApp > FEProblemBase::getMultiApp ( const std::string &  multi_app_name ) const

inherited

Get a MultiApp object by name.

Definition at line 6288 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 FEProblemBase::addTransfer(), FEProblemBase::execMultiAppTransfers(), MultiAppPositions::initialize(), and MultiAppTransfer::MultiAppTransfer().

getMultiAppFixedPointConvergenceName()

const ConvergenceName & FEProblemBase::getMultiAppFixedPointConvergenceName ( ) const

inherited

Gets the MultiApp fixed point convergence object name.

Definition at line 10588 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 FEProblemBase::addDefaultMultiAppFixedPointConvergence(), FixedPointSolve::examineFixedPointConvergence(), FixedPointIterationAdaptiveDT::init(), FixedPointSolve::initialSetup(), SteffensenSolve::initialSetup(), FixedPointSolve::solve(), and FixedPointSolve::solveStep().

getMultiAppTransferWarehouse()

const ExecuteMooseObjectWarehouse< Transfer > & FEProblemBase::getMultiAppTransferWarehouse ( Transfer::DIRECTION  direction ) const

inherited

Return the complete warehouse for MultiAppTransfer object for the given direction.

Definition at line 6434 of file FEProblemBase.C.

{
  if (direction == MultiAppTransfer::TO_MULTIAPP)
    return _to_multi_app_transfers;
  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
    return _from_multi_app_transfers;
  else
    return _between_multi_app_transfers;
}

getMultiAppWarehouse()

ExecuteMooseObjectWarehouse< MultiApp > & FEProblemBase::getMultiAppWarehouse ( )

inlineinherited

Definition at line 2660 of file FEProblemBase.h.

{ return _multi_apps; }

Referenced by MooseApp::collectCitations(), MooseApp::errorCheck(), and MooseApp::setOutputFileBase().

getNeighborMaterialPropertyStorage()

const MaterialPropertyStorage & FEProblemBase::getNeighborMaterialPropertyStorage ( )

inlineinherited

Definition at line 2139 of file FEProblemBase.h.

  {
    return _neighbor_material_props;
  }

getNonlinearConvergenceNames()

const std::vector< ConvergenceName > & FEProblemBase::getNonlinearConvergenceNames ( ) const

inherited

Gets the nonlinear system convergence object name(s).

Definition at line 10556 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 FEProblemBase::addDefaultNonlinearConvergence(), ReferenceResidualProblem::addDefaultNonlinearConvergence(), and FEProblemSolve::convergenceSetup().

getNonlinearEvaluableElementRange()

const ConstElemRange & FEProblemBase::getNonlinearEvaluableElementRange ( )

inherited

Definition at line 1026 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 )

virtualinherited

Reimplemented in FEProblem.

Definition at line 3088 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 )

inlineinherited

Definition at line 3886 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(), NonlinearThread::onInterfaceWithHRefinementMismatch(), 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

inlineinherited

Definition at line 3893 of file FEProblemBase.h.

{
  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
  return *_nl[sys_num];
}

getNonlinearSystemNames()

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

inlineinherited

Returns

the nolinear system names in the problem

Definition at line 3062 of file FEProblemBase.h.

{ return _nl_sys_names; }

Referenced by PhysicsBase::initializePhysics(), Console::meshChanged(), MultiSystemSolveObject::MultiSystemSolveObject(), ConsoleUtils::outputExecutionInformation(), and Console::outputSystemInformation().

getNumCyclesCompleted()

unsigned int FEProblemBase::getNumCyclesCompleted ( )

inlineinherited

Returns

The number of adaptivity cycles completed.

Definition at line 2205 of file FEProblemBase.h.

{ return _cycles_completed; }

getNumericType()

NumericType MFEMProblem::getNumericType ( ) const

inlineinherited

Retrieve the numeric type of the problem.

Definition at line 414 of file MFEMProblem.h.

{ return _num_type; }

Referenced by MFEMProblem::addDefaultProblemComposer(), MFEMProblem::addDefaultWeakForm(), addDefaultWeakForm(), MFEMComplexWeakFormProblemComposer::createProblemOperator(), and MFEMWeakFormProblemComposer::createProblemOperator().

getParam() [1/2]

template<typename T >

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

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns

The value of the parameter

Definition at line 406 of file MooseBase.h.

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

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

getParam() [2/2]

template<typename T1 , typename T2 >

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

inherited

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

Parameters

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

Returns

Vector of pairs of first and second parameters

Definition at line 443 of file MooseBase.h.

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

getPetscOptions()

Moose::PetscSupport::PetscOptions & FEProblemBase::getPetscOptions ( )

inlineinherited

Retrieve a writable reference the PETSc options (used by PetscSupport)

Definition at line 698 of file FEProblemBase.h.

{ return _petsc_options; }

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

inherited

Get the Positions object by its name.

Parameters

name	The name of the Positions object being retrieved

Returns

Const reference to the Positions object

Definition at line 5094 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

inherited

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

inherited

Get a read-only reference to the value associated with a Postprocessor that exists.

Parameters

name	The name of the post-processor
t_index	Flag for getting current (0), old (1), or older (2) values

Returns

The reference to the value at the given time index

Note: This method is only for retrieving values that already exist, the Postprocessor and PostprocessorInterface objects should be used rather than this method for creating and getting values within objects.

Definition at line 5259 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().

getProblemData() [1/2]

MFEMProblemData & MFEMProblem::getProblemData ( )

inlineinherited

Method to get the current MFEMProblemData object storing the current data specifying the FE problem.

Definition at line 321 of file MFEMProblem.h.

{ return _problem_data; }

Referenced by MFEMProblem::addFESpace(), MFEMProblem::addFESpaceHierarchy(), MFEMProblem::addGridFunction(), MFEMProblem::addMarker(), MFEMProblem::addSubMesh(), addVariable(), MFEMProblem::addVariable(), MFEMProblem::getComm(), MFEMProblem::getEquationSystem(), MFEMWeakFormBase::initEquationSystem(), MFEMCutTransitionSubMesh::labelMesh(), MFEMEigenproblem(), MFEMVariable::MFEMVariable(), MFEMProblem::resolveMFEMSolvers(), resolveMFEMSolvers(), MFEMProblem::setMesh(), MFEMProblemSolve::solve(), MFEMProblem::solverTypeString(), MultiAppMFEMCopyTransfer::transferVariables(), and MultiAppMFEMShapeEvaluationTransfer::transferVariables().

getProblemData() [2/2]

const MFEMProblemData & MFEMProblem::getProblemData ( ) const

inlineinherited

Return the current MFEM problem data in a const context.

Definition at line 326 of file MFEMProblem.h.

{ return _problem_data; }

getProblemOperators()

std::vector< std::shared_ptr< Moose::MFEM::ProblemOperatorBase > > & MFEMProblem::getProblemOperators ( )

inherited

Get vector of all ProblemOperators added to this problem.

Definition at line 560 of file MFEMProblem.C.

{
  return _problem_operators;
}

Referenced by MFEMProblem::setProblemOperators().

getRegularMaterialsWarehouse()

const MaterialWarehouse & FEProblemBase::getRegularMaterialsWarehouse ( ) const

inlineinherited

Definition at line 2393 of file FEProblemBase.h.

{ 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

inlineinherited

Provides const access the ReporterData object.

NOTE: There is a private non-const version of this function that uses a key object only constructable by the correct interfaces. This was done by design to encourage the use of the Reporter and ReporterInterface classes.

Definition at line 1402 of file FEProblemBase.h.

{ return _reporter_data; }

Referenced by ReporterTransferInterface::addReporterTransferMode(), ReporterTransferInterface::broadcastReporter(), ReporterTransferInterface::checkHasReporterValue(), ReporterTransferInterface::clearVectorReporter(), ConstantPostprocessor::ConstantPostprocessor(), AccumulateReporter::declareAccumulateHelper(), ReporterTransferInterface::declareClone(), ReporterTransferInterface::declareClone(), AccumulateReporter::declareLateValues(), VectorPostprocessor::declareVector(), ReporterTransferInterface::declareVectorClone(), ReporterTransferInterface::declareVectorClone(), FEProblemBase::execute(), PostprocessorInterface::getPostprocessorValueByNameInternal(), VectorPostprocessorInterface::getVectorPostprocessorByNameHelper(), VectorPostprocessorInterface::getVectorPostprocessorContextByNameHelper(), PostprocessorInterface::hasPostprocessorByName(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), MooseParsedFunctionWrapper::initialize(), ReporterPositions::initialize(), ReporterTimes::initialize(), ParsedConvergence::initializeSymbols(), JSONOutput::initialSetup(), PostprocessorInterface::isDefaultPostprocessorValueByName(), ReporterDebugOutput::output(), Receiver::Receiver(), ReporterTransferInterface::resizeReporter(), ReporterTransferInterface::sumVectorReporter(), ReporterTransferInterface::transferFromVectorReporter(), ReporterTransferInterface::transferReporter(), and ReporterTransferInterface::transferToVectorReporter().

getReporterData() [2/2]

ReporterData & FEProblemBase::getReporterData ( ReporterData::WriteKey  )

inlineinherited

Provides non-const access the ReporterData object that is used to store reporter values.

see ReporterData.h

Definition at line 1409 of file FEProblemBase.h.

{ return _reporter_data; }

getRestartableData()

template<typename T , typename... Args>

const T & Restartable::getRestartableData ( const std::string &  data_name ) const

protectedinherited

Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object.

Forwarded arguments are not allowed in this case because we assume that the object is restarted and we won't need different constructors to initialize it.

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

Parameters

data_name

The name of the data (usually just use the same name as the member variable)

Definition at line 294 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, nullptr).get();
}

getRestartableEquationSystems()

const RestartableEquationSystems & FEProblemBase::getRestartableEquationSystems ( ) const

inherited

Get the RestartableEquationSystems object.

Definition at line 6965 of file FEProblemBase.C.

{
  return _req.get();
}

Referenced by LinearFVGradientManager::checkRestartedGradientHistory().

getRHSCoefficient()

Moose::MFEM::EigenRHSCoefficient MFEMEigenproblem::getRHSCoefficient

(

)

Returns the coefficient used to scale the right-hand side of the eigenproblem equation.

Definition at line 55 of file MFEMEigenproblem.C.

{
  if (isParamSetByUser("rhs_matrix_coefficient"))
    return &getCoefficients().getMatrixCoefficient(
        getParam<MFEMMatrixCoefficientName>("rhs_matrix_coefficient"));
  return &getCoefficients().getScalarCoefficient(
      getParam<MFEMScalarCoefficientName>("rhs_coefficient"));
}

getSampler()

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

virtualinherited

Definition at line 3154 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  )

overridevirtualinherited

Returns the scalar variable reference from whichever system contains it.

Implements SubProblem.

Definition at line 6941 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 FEProblemBase::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 )

inlineinherited

Get non-constant reference to a solver system.

Parameters

sys_num

The number of the solver system

Definition at line 3900 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

inlineinherited

Get a constant reference to a solver system.

Parameters

sys_num

The number of the solver system

Definition at line 3908 of file FEProblemBase.h.

{
  mooseAssert(sys_num < _solver_systems.size(),
              "System number greater than the number of solver systems");
  return *_solver_systems[sys_num];
}

getSolverSystemNames()

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

inlineinherited

Returns

the solver system names in the problem

Definition at line 3070 of file FEProblemBase.h.

{ return _solver_sys_names; }

Referenced by ConsoleUtils::outputExecutionInformation().

getStandardVariable()

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

overridevirtualinherited

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

Implements SubProblem.

Definition at line 6881 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(), MOOSEQuantityToNEML2< T, state >::MOOSEQuantityToNEML2(), FEProblemBase::projectFunctionOnCustomRange(), LinearFVKernel::requestVariableCellGradient(), and ElementSubdomainModifierBase::storeOverriddenDofValues().

getSteadyStateConvergenceName()

const ConvergenceName & FEProblemBase::getSteadyStateConvergenceName ( ) const

inherited

Gets the steady-state detection convergence object name.

Definition at line 10597 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 FEProblemBase::addDefaultSteadyStateConvergence(), TransientBase::convergedToSteadyState(), and TransientBase::init().

getSystem()

System & FEProblemBase::getSystem ( const std::string &  var_name )

overridevirtualinherited

Returns the equation system containing the variable provided.

Implements SubProblem.

Definition at line 6953 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 FEProblemBase::addObjectParamsHelper(), MultiApp::appTransferVector(), FunctorChangeFunctorMaterialTempl< is_ad >::FunctorChangeFunctorMaterialTempl(), ElementSubdomainModifierBase::gatherPatchElements(), and ElementSubdomainModifierBase::storeOverriddenDofValues().

getSystemBase() [1/3]

SystemBase & FEProblemBase::getSystemBase ( const std::string &  sys_name )

inherited

Get non-constant reference to a system in this problem.

Parameters

sys_name

The name of the system

Definition at line 10315 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 )

virtualinherited

Get non-constant reference to a system in this problem.

Parameters

sys_num

The number of the system

Definition at line 10327 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

virtualinherited

Get constant reference to a system in this problem.

Parameters

sys_num

The number of the system

Definition at line 10306 of file FEProblemBase.C.

{
  if (sys_num < _solver_systems.size())
    return *_solver_systems[sys_num];
 
  return *_aux;
}

Referenced by FEProblemBase::addObjectParamsHelper(), PhysicsBase::copyVariablesFromMesh(), FEProblemBase::getSystemBase(), FEProblemBase::projectFunctionOnCustomRange(), and ElementSubdomainModifierBase::restoreOverriddenDofValues().

getTimeFromStateArg()

Real FEProblemBase::getTimeFromStateArg ( const Moose::StateArg &  state ) const

inherited

Returns the time associated with the requested state.

Definition at line 7975 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

inherited

Get Transfers by ExecFlagType and direction.

Definition at line 6412 of file FEProblemBase.C.

{
  if (direction == MultiAppTransfer::TO_MULTIAPP)
    return _to_multi_app_transfers[type].getActiveObjects();
  else if (direction == MultiAppTransfer::FROM_MULTIAPP)
    return _from_multi_app_transfers[type].getActiveObjects();
  else
    return _between_multi_app_transfers[type].getActiveObjects();
}

getTransfers() [2/2]

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

inherited

Definition at line 6423 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

privateinherited

Definition at line 5685 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 FEProblemBase::computeUserObjectByName(), and FEProblemBase::computeUserObjects().

getUOQuery()

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

privateinherited

Definition at line 5667 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 FEProblemBase::computeUserObjectByName(), and FEProblemBase::computeUserObjects().

getUserObject()

template<class T >

T & FEProblemBase::getUserObject ( const std::string &  name, unsigned int  tid = 0  ) const

inlineinherited

Get the user object by its name.

Parameters

name	The name of the user object being retrieved

Returns

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 TorchFEInterpolation::syncWithMainThread().

getUserObjectBase()

const UserObject & FEProblemBase::getUserObjectBase ( const std::string &  name, const THREAD_ID  tid = 0  ) const

inherited

Get the user object by its name.

Parameters

name	The name of the user object being retrieved
tid	The thread of the user object (defaults to 0)

Returns

Const reference to the user object

Definition at line 5071 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(), FEProblemBase::checkUserObjectNameCollision(), UserObjectInterface::getUserObjectFromFEProblem(), MultiAppCloneReporterTransfer::initialSetup(), MultiAppConservativeTransfer::initialSetup(), and Terminator::initialSetup().

getUserObjectJacobianVariables()

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

inlineinherited

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  )

inlinevirtualinherited

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

overridevirtualinherited

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

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

Implements SubProblem.

Definition at line 6871 of file FEProblemBase.C.

{
  return getVariableHelper(
      tid, var_name, expected_var_type, expected_var_field_type, _solver_systems, *_aux);
}

Referenced by FEProblemBase::addFVInitialCondition(), FEProblemBase::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(), TorchFEInterpolation::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

virtualinherited

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 FEProblemBase::getVariable().

getVariableHelper() [2/2]

template<typename T >

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

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

virtualinherited

Returns a list of all the variables in the problem (both from the NL and Aux systems.

Definition at line 10015 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

inherited

Return the VPP object given the name.

Parameters

object_name

The name of the VPP object

Returns

Desired VPP object

This is used by various output objects as well as the scatter value handling.

See also

CSV.C, XMLOutput.C, VectorPostprocessorInterface.C

Definition at line 5303 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

inherited

Get a read-only reference to the vector value associated with the VectorPostprocessor.

Parameters

object_name	The name of the VPP object.
vector_name	The namve of the decalred vector within the object.

Returns

Referent to the vector of data.

Note: This method is only for retrieving values that already exist, the VectorPostprocessor and VectorPostprocessorInterface objects should be used rather than this method for creating and getting values within objects.

Definition at line 5284 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 FEProblemBase::addCachedResidualDirectly(), Assembly::cacheResidual(), Assembly::cacheResidualNodes(), DisplacedProblem::getVectorTag(), SubProblem::getVectorTags(), TaggingInterface::prepareVectorTagInternal(), TaggingInterface::prepareVectorTagLower(), TaggingInterface::prepareVectorTagNeighbor(), FEProblemBase::setResidual(), and FEProblemBase::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);
}

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

getVectorTags() [1/2]

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

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 FEProblemBase::computeLinearSystemSys(), NonlinearSystemBase::computeNodalBCsResidual(), EigenProblem::computeResidualAB(), FEProblemBase::computeResidualAndJacobian(), EigenProblem::computeResidualTag(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), DisplacedProblem::getVectorTags(), SubProblem::numVectorTags(), ComputeMortarFunctor::operator()(), and FEProblemBase::setCurrentResidualVectorTags().

getVectorVariable()

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

overridevirtualinherited

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

Implements SubProblem.

Definition at line 6905 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    if (sys->hasVariable(var_name))
      return sys->getFieldVariable<RealVectorValue>(tid, var_name);
  if (_aux->hasVariable(var_name))
    return _aux->getFieldVariable<RealVectorValue>(tid, var_name);
 
  mooseError("Unknown variable " + var_name);
}

getXFEM()

std::shared_ptr< XFEMInterface > FEProblemBase::getXFEM ( )

inlineinherited

Get a pointer to the XFEM controller object.

Definition at line 2222 of file FEProblemBase.h.

{ return _xfem; }

ghostedElems()

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

inlinevirtualinherited

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

Returns

The list

Reimplemented in DisplacedProblem.

Definition at line 683 of file SubProblem.h.

{ return _ghosted_elems; }

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

ghostGhostedBoundaries()

void FEProblemBase::ghostGhostedBoundaries ( )

overridevirtualinherited

Causes the boundaries added using addGhostedBoundary to actually be ghosted.

Implements SubProblem.

Definition at line 2526 of file FEProblemBase.C.

{
  TIME_SECTION("ghostGhostedBoundaries", 3, "Ghosting Ghosted Boundaries");
 
  _mesh.ghostGhostedBoundaries();
 
  if (_displaced_problem)
    _displaced_mesh->ghostGhostedBoundaries();
}

Referenced by DisplacedProblem::ghostGhostedBoundaries(), FEProblemBase::init(), and FEProblemBase::meshChanged().

handleException()

void FEProblemBase::handleException ( const std::string &  calling_method )

privateinherited

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

{
  translateCaughtException(calling_method);
  checkExceptionAndStopSolve();
}

Referenced by FEProblemBase::computeBounds(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::computeResidualTags().

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

inherited

Method to check whether or not a list of active material roperties has been set.

This method is called by reinitMaterials to determine whether Material computeProperties methods need to be called. If the return is False, this check prevents unnecessary material property computation

Parameters

tid	The thread id

Returns

True if there has been a list of active material properties set, False otherwise

Definition at line 7079 of file FEProblemBase.C.

{
  return _has_active_material_properties[tid];
}

Referenced by ComputeMarkerThread::onElement(), FEProblemBase::reinitMaterials(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsInterface(), FEProblemBase::reinitMaterialsNeighbor(), and FEProblemBase::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.

{ return _pars.hasBase(); }

hasBlockMaterialProperty()

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

virtualinherited

Check if a material property is defined on a block.

Definition at line 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

virtualinherited

Returns true if the problem has a Convergence object of the given name.

Definition at line 3036 of file FEProblemBase.C.

{
  return _convergences.hasActiveObject(name, tid);
}

Referenced by ParsedConvergence::initializeSymbols().

hasDampers()

bool FEProblemBase::hasDampers ( )

inlineinherited

Whether or not this system has dampers.

Definition at line 1676 of file FEProblemBase.h.

{ return _has_dampers; }

Referenced by NonlinearSystemBase::preInit(), and NonlinearSystem::solve().

hasDistribution()

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

virtualinherited

Definition at line 3112 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 ( )

inlinevirtualinherited

Whether or not an exception has occurred.

Definition at line 535 of file FEProblemBase.h.

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

virtualinherited

Definition at line 2978 of file FEProblemBase.C.

{
  return _functions.hasActiveObject(name, tid);
}

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVBCs(), DiffusionFV::addFVKernels(), FunctorIC::FunctorIC(), FEProblemBase::getFunction(), FunctionInterface::hasFunctionByName(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), ParsedConvergence::initializeSymbols(), and MooseParsedFunction::initialSetup().

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

inherited

Check if an FV gradient method with a given name exists.

Definition at line 5147 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

inherited

Check if an FV interpolation method with a given name exists.

Definition at line 5221 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

inlineinherited

Return a Boolean indicating whether initial AMR is turned on.

Definition at line 2210 of file FEProblemBase.h.

{ return _adaptivity.getInitialSteps() > 0; }

hasInitialAdaptivity() [2/2]

bool FEProblemBase::hasInitialAdaptivity ( ) const

inlineinherited

Return a Boolean indicating whether initial AMR is turned on.

Definition at line 2215 of file FEProblemBase.h.

{ return false; }

hasJacobian()

bool FEProblemBase::hasJacobian ( ) const

inherited

Returns _has_jacobian.

Definition at line 10230 of file FEProblemBase.C.

{
  return _has_jacobian;
}

Referenced by DisplacedProblem::prepare().

hasKokkosFunction()

virtual bool FEProblemBase::hasKokkosFunction ( const std::string &  name ) const

virtualinherited

Get whether a Kokkos function exists.

Parameters

name	The Kokkos function name

Returns

Whether a Kokkos function exists

Referenced by FEProblemBase::getKokkosFunction().

hasKokkosObjects()

bool FEProblemBase::hasKokkosObjects ( ) const

inlineinherited

Returns

whether any Kokkos object was added in the problem

Definition at line 3094 of file FEProblemBase.h.

{ return _has_kokkos_objects; }

Referenced by MooseMesh::update().

hasKokkosResidualObjects()

bool FEProblemBase::hasKokkosResidualObjects ( ) const

inlineinherited

Returns

whether any Kokkos residual object was added in the problem

Definition at line 3098 of file FEProblemBase.h.

{ return _has_kokkos_residual_objects; }

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

inherited

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 FEProblemBase::checkUserObjectNameCollision(), UserObjectInterface::getUserObjectFromFEProblem(), and UserObjectInterface::hasUserObjectByName().

hasLinearConvergenceObjects()

bool FEProblemBase::hasLinearConvergenceObjects ( ) const

inherited

Whether we have linear convergence objects.

Definition at line 10564 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().

hasMFEMObject()

bool MFEMProblem::hasMFEMObject ( const std::string &  system, const std::string &  name  ) const

inherited

Determine whether an MFEM object with the supplied system and name exists.

Definition at line 926 of file MFEMProblem.C.

{
  std::vector<MooseObject *> objs;
  theWarehouse()
      .query()
      .condition<AttribSystem>(system)
      .condition<AttribThread>(0)
      .condition<AttribName>(name)
      .queryInto(objs);
  return !objs.empty();
}

Referenced by MFEMProblem::addMFEMFESpaceFromMOOSEVariable().

hasMortarCoupling()

virtual bool FEProblemBase::hasMortarCoupling ( ) const

inlinevirtualinherited

Whether the simulation has mortar coupling.

Definition at line 2783 of file FEProblemBase.h.

{ return _has_mortar; }

hasMultiApp()

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

inherited

Definition at line 6282 of file FEProblemBase.C.

{
  return _multi_apps.hasActiveObject(multi_app_name);
}

Referenced by FEProblemBase::getMultiApp().

hasMultiApps() [1/2]

bool FEProblemBase::hasMultiApps ( ) const

inlineinherited

Returns whether or not the current simulation has any multiapps.

Definition at line 1662 of file FEProblemBase.h.

{ return _multi_apps.hasActiveObjects(); }

Referenced by DefaultMultiAppFixedPointConvergence::checkConvergence(), FEProblemBase::checkProblemIntegrity(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), FixedPointIterationAdaptiveDT::init(), and DefaultMultiAppFixedPointConvergence::preIteration().

hasMultiApps() [2/2]

bool FEProblemBase::hasMultiApps ( ExecFlagType  type ) const

inherited

Definition at line 6276 of file FEProblemBase.C.

{
  return _multi_apps[type].hasActiveObjects();
}

hasNeighborCoupling()

virtual bool FEProblemBase::hasNeighborCoupling ( ) const

inlinevirtualinherited

Whether the simulation has neighbor coupling.

Definition at line 2778 of file FEProblemBase.h.

{ return _has_internal_edge_residual_objects; }

hasNonlocalCoupling()

virtual bool FEProblemBase::hasNonlocalCoupling ( ) const

inlineoverridevirtualinherited

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

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

Implements SubProblem.

Definition at line 3049 of file FEProblemBase.h.

{ return _has_nonlocal_coupling; }

Referenced by DisplacedProblem::hasNonlocalCoupling().

hasPostprocessor()

bool FEProblemBase::hasPostprocessor ( const std::string &  name ) const

inherited

Deprecated.

Use hasPostprocessorValueByName

Definition at line 5276 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

inherited

Whether or not a Postprocessor value exists by a given name.

Parameters

name	The name of the Postprocessor

Returns

True if a Postprocessor value exists

Note: You should prioritize the use of PostprocessorInterface::hasPostprocessor and PostprocessorInterface::hasPostprocessorByName over this method when possible.

Definition at line 5234 of file FEProblemBase.C.

{
  return _reporter_data.hasReporterValue<PostprocessorValue>(PostprocessorReporterName(name));
}

Referenced by DiffusionCG::addFEBCs(), DiffusionCG::addFEKernels(), DiffusionFV::addFVKernels(), FunctorExtremaPositions::FunctorExtremaPositions(), FEProblemBase::hasPostprocessor(), MooseParsedFunction::initialSetup(), and FunctorIC::value().

hasScalarVariable()

bool FEProblemBase::hasScalarVariable ( const std::string &  var_name ) const

overridevirtualinherited

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

Implements SubProblem.

Definition at line 6929 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 FEProblemBase::addInitialCondition(), FEProblemBase::addObjectParamsHelper(), EigenProblem::adjustEigenVector(), FEProblemBase::checkDuplicatePostprocessorVariableNames(), AdvancedOutput::initAvailableLists(), MooseParsedFunctionWrapper::initialize(), ChainControlParsedFunctionWrapper::initializeFunctionInputs(), MooseParsedFunction::initialSetup(), AdvancedOutput::initShowHideLists(), and Split::setup().

hasSetMultiAppFixedPointConvergenceName()

bool FEProblemBase::hasSetMultiAppFixedPointConvergenceName ( ) const

inlineinherited

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

inlineinherited

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

inherited

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

inherited

Definition at line 6861 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

inlineinherited

Returns whether or not this Problem has a TimeIntegrator.

Definition at line 2507 of file FEProblemBase.h.

{ return _has_time_integrator; }

Referenced by TransientBase::setupTimeIntegrator().

hasUOAuxStateCheck()

bool FEProblemBase::hasUOAuxStateCheck ( ) const

inlineinherited

Whether or not MOOSE will perform a user object/auxiliary kernel state check.

Definition at line 221 of file FEProblemBase.h.

{ return _uo_aux_state_check; }

hasUserObject()

bool FEProblemBase::hasUserObject ( const std::string &  name ) const

inherited

Check if there if a user object of given name.

Parameters

name	The name of the user object being checked for

Returns

true if the user object exists, false otherwise

Definition at line 5109 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 FEProblemBase::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

overridevirtualinherited

Whether or not this problem has the variable.

Implements SubProblem.

Definition at line 6849 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 FEProblemBase::addFVInitialCondition(), FEProblemBase::addInitialCondition(), FEProblemBase::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

inlineinherited

Method for reading wehther we have any ad objects.

Definition at line 782 of file SubProblem.h.

{ return _have_ad_objects; }

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::init().

haveADObjects() [2/3]

virtual void SubProblem::haveADObjects ( bool  have_ad_objects )

inlinevirtualinherited

Method for setting whether we have any ad objects.

Reimplemented from SubProblem.

Definition at line 778 of file SubProblem.h.

{ _have_ad_objects = have_ad_objects; }

haveADObjects() [3/3]

void FEProblemBase::haveADObjects ( bool  have_ad_objects )

overridevirtualinherited

Method for setting whether we have any ad objects.

Reimplemented from SubProblem.

Definition at line 10298 of file FEProblemBase.C.

{
  _have_ad_objects = have_ad_objects;
  if (_displaced_problem)
    _displaced_problem->SubProblem::haveADObjects(have_ad_objects);
}

haveDisplaced()

bool FEProblemBase::haveDisplaced ( ) const

inlinefinaloverridevirtualinherited

Whether we have a displaced problem in our simulation.

Implements SubProblem.

Definition at line 2883 of file FEProblemBase.h.

{ return _displaced_problem.get(); }

haveFV()

virtual bool FEProblemBase::haveFV ( ) const

inlineoverridevirtualinherited

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

Implements SubProblem.

Definition at line 3047 of file FEProblemBase.h.

{ return _have_fv; }

Referenced by NonlinearSystemBase::checkKernelCoverage(), NonlinearSystemBase::computeJacobianInternal(), NonlinearThread::computeOnElement(), ComputeFullJacobianThread::computeOnElement(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), NonlinearSystemBase::customSetup(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), ComputeResidualThread::determineObjectWarehouses(), DisplacedProblem::haveFV(), FEProblemBase::init(), NonlinearSystemBase::initialSetup(), FEProblemBase::meshChanged(), FEProblemBase::projectSolution(), FEProblemBase::swapBackMaterialsNeighbor(), and NonlinearSystemBase::timestepSetup().

haveXFEM()

bool FEProblemBase::haveXFEM ( )

inlineinherited

Find out whether the current analysis is using XFEM.

Definition at line 2225 of file FEProblemBase.h.

{ return _xfem != nullptr; }

Referenced by FixedPointSolve::solveStep(), TransientBase::takeStep(), and FEProblemBase::updateMeshXFEM().

hRefine()

bool MFEMProblem::hRefine ( )

inlineinherited

If AMR is enabled, request (and perform if needed) h-refinement.

Definition at line 379 of file MFEMProblem.h.

{ return _problem_data.refiner && _problem_data.refiner->hRefine(); }

Referenced by MFEMProblemSolve::solve().

identifyVariableGroupsInNL()

bool FEProblemBase::identifyVariableGroupsInNL ( ) const

inlineinherited

Whether to identify variable groups in nonlinear systems.

This affects dof ordering

Definition at line 3054 of file FEProblemBase.h.

{ return _identify_variable_groups_in_nl; }

Referenced by NonlinearSystemBase::NonlinearSystemBase().

ignoreZerosInJacobian()

bool FEProblemBase::ignoreZerosInJacobian ( ) const

inlineinherited

Will return true if zeros in the Jacobian are to be dropped from the sparsity pattern.

Note that this can make preserving the matrix sparsity pattern impossible.

Definition at line 2479 of file FEProblemBase.h.

{ return _ignore_zeros_in_jacobian; }

Referenced by NonlinearSystemBase::constraintJacobians(), and NonlinearSystemBase::setMatrixOptions().

immediatelyPrintInvalidSolution()

bool FEProblemBase::immediatelyPrintInvalidSolution ( ) const

inlineinherited

Whether or not the solution invalid warnings are printed out immediately.

Definition at line 2504 of file FEProblemBase.h.

{ return _immediately_print_invalid_solution; }

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

incrementMultiAppTStep()

void FEProblemBase::incrementMultiAppTStep ( ExecFlagType  type )

inherited

Advance the MultiApps t_step (incrementStepOrReject) associated with the ExecFlagType.

Definition at line 6680 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 ( )

overridevirtualinherited

Implements Problem.

Reimplemented in EigenProblem, and FEProblem.

Definition at line 7359 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(), "'.");
  }
 
  for (const auto param :
       {"constant_null_space_variables", "constant_transpose_null_space_variables"})
    for (const auto & var : getParam<std::vector<VariableName>>(param))
      if (std::none_of(_nl.begin(),
                       _nl.end(),
                       [&var](const auto & nl)
                       { return nl->hasVariable(var) || nl->hasScalarVariable(var); }))
        paramError(param, "Variable '", var, "' is not in any nonlinear system.");
 
  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  )

inherited

Initialize stateful properties for elements in a specific elem_range This is needed when elements/boundary nodes are added to a specific subdomain at an intermediate step.

Definition at line 9598 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 ( )

virtualinherited

Definition at line 9258 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

inlineinherited

Returns

Whether the problem was initialized, i.e. whether init() has executed

Definition at line 169 of file FEProblemBase.h.

{ return _initialized; }

Referenced by MooseMesh::update().

initialSetup()

void MFEMProblem::initialSetup ( )

overridevirtualinherited

Reimplemented from FEProblemBase.

Definition at line 85 of file MFEMProblem.C.

{
  ExternalProblem::initialSetup();
 
  std::vector<MFEMExecutedObject *> objects;
  theWarehouse()
      .query()
      .condition<AttribSystem>("MFEMExecutedObject")
      .condition<AttribThread>(0)
      .queryInto(objects);
  for (auto * const object : objects)
    object->initialSetup();
}

Referenced by MFEMSteady::init().

initKokkos()

void FEProblemBase::initKokkos ( )

inherited

Construct Kokkos assembly and systems and allocate Kokkos material property storages.

Referenced by FEProblemBase::init().

initKokkosStatefulProps()

void FEProblemBase::initKokkosStatefulProps ( )

inherited

Referenced by FEProblemBase::initElementStatefulProps().

initNullSpaceVectors()

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

virtualinherited

Definition at line 917 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 ( )

virtualinherited

Reinitialize PETSc output for proper linear/nonlinear iteration display.

This also may be used for some PETSc-related solver settings

Reimplemented in EigenProblem.

Definition at line 7954 of file FEProblemBase.C.

{
  _app.getOutputWarehouse().solveSetup();
  Moose::PetscSupport::petscSetDefaults(*this);
}

Referenced by FEProblemBase::possiblyRebuildGeomSearchPatches(), AStableDirk4::solve(), ExplicitRK2::solve(), ExplicitTVDRK2::solve(), ImplicitMidpoint::solve(), LStableDirk2::solve(), LStableDirk3::solve(), LStableDirk4::solve(), and FEProblemBase::solve().

initXFEM()

void FEProblemBase::initXFEM ( std::shared_ptr< XFEMInterface >  xfem )

inherited

Create XFEM controller object.

Definition at line 9356 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.

{ 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(), getRHSCoefficient(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), MFEMMesh::init(), PhysicsBase::initializePhysics(), LibtorchNeuralNetControl::initialSetup(), ElementSubdomainModifierBase::initialSetup(), LibtorchNeuralNetControl::loadControlNeuralNetFromFile(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MFEMEigenproblem(), MFEMGeneratedMeshGenerator::MFEMGeneratedMeshGenerator(), MFEMVariable::MFEMVariable(), MooseApp::MooseApp(), MortarConstraintBase::MortarConstraintBase(), MoveNodesByParsedExpressionModifier::moveNodes(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::run(), MooseApp::runInputFile(), MooseApp::runInputs(), MooseApp::setMFEMDevice(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), MFEMHypreBoomerAMG::SetSolverParameters(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), SmoothMeshGenerator::SmoothMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SurfaceSubdomainsFromAllNormalsGenerator::SurfaceSubdomainsFromAllNormalsGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), TriToQuadConverter::TriToQuadConverter(), XYFrontalDelaunayGenerator::XYFrontalDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 199 of file MooseBase.h.

{ return _pars.isParamValid(name); }

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

isSNESMFReuseBaseSetbyUser()

bool FEProblemBase::isSNESMFReuseBaseSetbyUser ( )

inlineinherited

Return a flag to indicate if _snesmf_reuse_base is set by users.

Definition at line 2704 of file FEProblemBase.h.

{ return _snesmf_reuse_base_set_by_user; }

isSolverSystemNonlinear()

bool FEProblemBase::isSolverSystemNonlinear ( const unsigned int  sys_num )

inlineinherited

Check if the solver system is nonlinear.

Definition at line 2957 of file FEProblemBase.h.

{ return sys_num < _num_nl_sys; }

Referenced by FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addKernel(), FEProblemBase::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.

{ return _termination_requested; };

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

isTransient()

virtual bool FEProblemBase::isTransient ( ) const

inlineoverridevirtualinherited

Implements SubProblem.

Definition at line 592 of file FEProblemBase.h.

{ return _transient; }

Referenced by MFEMProblem::addDefaultProblemComposer(), MFEMProblem::addDefaultWeakForm(), MFEMProblem::addVariable(), FixedPointSolve::autoAdvance(), FEProblemBase::checkExceptionAndStopSolve(), MFEMTimeDependentWeakFormProblemComposer::createProblemOperator(), PhysicsBase::isTransient(), DisplacedProblem::isTransient(), PIDTransientControl::PIDTransientControl(), PseudoTimestep::PseudoTimestep(), TimePeriodBase::TimePeriodBase(), Coupleable::validateExecutionerType(), and ScalarCoupleable::validateExecutionerType().

jacobianSetup()

void FEProblemBase::jacobianSetup ( )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 10620 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 FEProblemBase::jacobianSetup(), and NonlinearSystemBase::jacobianSetup().

joinAndFinalize()

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

privateinherited

Definition at line 5592 of file FEProblemBase.C.

{
  std::vector<UserObject *> objs;
  query.queryInto(objs);
  // The same user objects exist on every process, so every process returns here or none does
  if (objs.empty())
    return;
 
  if (!isgen)
  {
    // join all threaded user objects (i.e. not regular general user objects) to the primary
    // thread
    translateUserObjectExceptions(
        [&objs]()
        {
          for (auto obj : objs)
            if (obj->primaryThreadCopy())
              obj->primaryThreadCopy()->threadJoin(*obj);
        });
    checkExceptionAndStopSolve();
  }
 
  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;
      translateUserObjectExceptions(
          [obj]()
          {
            obj->initialize();
            obj->execute();
          });
      checkExceptionAndStopSolve();
    }
 
    // An exception raised by finalize() is communicated once all objects have been finalized, so
    // that a process raising one does not skip the communication in the finalize() of the
    // remaining objects
    translateUserObjectExceptions([obj]() { 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());
  }
 
  checkExceptionAndStopSolve();
}

Referenced by FEProblemBase::computeUserObjectsInternal().

kokkosAssembly() [1/2]

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

inlineinherited

Definition at line 365 of file FEProblemBase.h.

{ return _kokkos_assembly; }

kokkosAssembly() [2/2]

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

inlineinherited

Definition at line 366 of file FEProblemBase.h.

{ return _kokkos_assembly; }

kokkosJoinAndFinalize()

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

privateinherited

linearSysNum()

unsigned int FEProblemBase::linearSysNum ( const LinearSystemName &  linear_sys_name ) const

overridevirtualinherited

Returns

the linear system number corresponding to the provided linear_sys_name

Implements SubProblem.

Definition at line 7521 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(), FEProblemBase::computeLinearSystemSys(), LinearSystem::computeLinearSystemTags(), and DisplacedProblem::linearSysNum().

lineSearch()

void FEProblemBase::lineSearch ( )

virtualinherited

execute MOOSE line search

Definition at line 3082 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

inherited

Output information about the object just added to the problem.

Definition at line 4822 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 FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarKernel(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addFunction(), MFEMProblem::addFunction(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVGradientMethod(), FEProblemBase::addFVInterpolationMethod(), FEProblemBase::addIndicator(), FEProblemBase::addInitialCondition(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObject(), FEProblemBase::addOutput(), FEProblemBase::addPredictor(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), FEProblemBase::addVariable(), FEProblemBase::setAuxKernelParamsAndLog(), and FEProblemBase::setResidualObjectParamsAndLog().

makeLinearSolverParams()

SolverParams FEProblemBase::makeLinearSolverParams ( )

staticprivateinherited

Make basic solver params for linear solves.

Definition at line 10847 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::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]

const MFEMMesh & MFEMProblem::mesh ( ) const

overridevirtualinherited

Reimplemented from FEProblemBase.

Definition at line 825 of file MFEMProblem.C.

{
  return const_cast<MFEMProblem *>(this)->mesh();
}

mesh() [2/4]

MFEMMesh & MFEMProblem::mesh ( )

overridevirtualinherited

Overwritten mesh() method from base MooseMesh to retrieve the correct mesh type, in this case MFEMMesh.

Reimplemented from FEProblemBase.

Definition at line 816 of file MFEMProblem.C.

{
  auto * mfem_mesh = dynamic_cast<MFEMMesh *>(&_mesh);
  mooseAssert(mfem_mesh,
              "The mesh for an MFEMProblem must be MFEMFileMesh or MFEMMeshGeneratorMesh.");
  return *mfem_mesh;
}

Referenced by MFEMProblem::addMFEMFESpaceFromMOOSEVariable(), MFEMProblem::displaceMesh(), MFEMProblem::getMeshDisplacementGridFunction(), MFEMProblem::mesh(), and MFEMProblem::setMesh().

mesh() [3/4]

MooseMesh & FEProblemBase::mesh ( bool  use_displaced )

inherited

Definition at line 811 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

overridevirtualinherited

Implements SubProblem.

Definition at line 802 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 ( )

inlineprotectedvirtualinherited

Deprecated.

Users should switch to overriding the meshChanged which takes arguments

Definition at line 3113 of file FEProblemBase.h.

{}

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::initialAdaptMesh(), FEProblemBase::meshChanged(), FEProblemBase::timestepSetup(), FEProblemBase::uniformRefine(), and FEProblemBase::updateMeshXFEM().

meshChanged() [2/2]

void FEProblemBase::meshChanged ( bool  intermediate_change, bool  contract_mesh, bool  clean_refinement_flags  )

virtualinherited

Update data after a mesh change.

Iff intermediate_change is true, only perform updates as necessary to prepare for another mesh change immediately-subsequent. An example of data that is not updated during an intermediate change is libMesh System matrix data. An example of data that \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 9414 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 ( )

protectedvirtualinherited

Update data after a mesh displaced.

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

mooseError()

template<typename... Args>

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

inlineinherited

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

Definition at line 271 of file MooseBase.h.

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

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

mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 290 of file MooseBase.h.

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

mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 334 of file MooseBase.h.

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

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

mooseWarning() [1/2]

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

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

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

mooseWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

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

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

mooseWarningNonPrefixed() [1/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 308 of file MooseBase.h.

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

mooseWarningNonPrefixed() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

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

mortarData() [1/2]

MortarInterfaceWarehouse & FEProblemBase::mortarData ( )

inlineinherited

Definition at line 2773 of file FEProblemBase.h.

{ return *_mortar_data; }

mortarData() [2/2]

const MortarInterfaceWarehouse & FEProblemBase::mortarData ( ) const

inlineinherited

Returns the mortar data object.

Definition at line 2772 of file FEProblemBase.h.

{ return *_mortar_data; }

name()

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

inlineinherited

Get the name of the class.

Returns

The name of the class

Definition at line 103 of file MooseBase.h.

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

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

needBoundaryMaterialOnSide()

bool FEProblemBase::needBoundaryMaterialOnSide ( BoundaryID  bnd_id, const THREAD_ID  tid  )

inherited

These methods are used to determine whether stateful material properties need to be stored on internal sides.

There are five situations where this may be the case: 1) DGKernels 2) IntegratedBCs 3)InternalSideUserObjects 4)ElementalAuxBCs 5)InterfaceUserObjects

Method 1:

Parameters

bnd_id	the boundary id for which to see if stateful material properties need to be stored
tid	the THREAD_ID of the caller

Returns

Boolean indicating whether material properties need to be stored

Method 2:

Parameters

subdomain_id	the subdomain id for which to see if stateful material properties need to be stored
tid	the THREAD_ID of the caller

Returns

Boolean indicating whether material properties need to be stored

Definition at line 10057 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(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFaceOnBoundary(), and FEProblemBase::reinitMaterialsNeighborOnBoundary().

needFV()

virtual void FEProblemBase::needFV ( )

inlineoverridevirtualinherited

marks this problem as including/needing finite volume functionality.

Implements SubProblem.

Definition at line 3046 of file FEProblemBase.h.

{ _have_fv = true; }

Referenced by DiffusionFV::initializePhysicsAdditional(), and DisplacedProblem::needFV().

needInterfaceMaterialOnSide()

bool FEProblemBase::needInterfaceMaterialOnSide ( BoundaryID  bnd_id, const THREAD_ID  tid  )

inherited

Definition at line 10096 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(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsInterface(), and FEProblemBase::reinitMaterialsNeighborOnBoundary().

needInternalNeighborSideMaterial()

bool FEProblemBase::needInternalNeighborSideMaterial ( SubdomainID  subdomain_id, const THREAD_ID  tid  )

inherited

Definition at line 10133 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 FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsNeighborOnBoundary(), ComputeMaterialsObjectThread::subdomainChanged(), and ProjectMaterialProperties::subdomainChanged().

needSolutionState()

void FEProblemBase::needSolutionState ( unsigned int  oldest_needed, Moose::SolutionIterationType  iteration_type  )

inherited

Declare that we need up to old (1) or older (2) solution states for a given type of iteration.

Parameters

oldest_needed	oldest solution state needed
iteration_type	the type of iteration for which old/older states are needed

Definition at line 884 of file FEProblemBase.C.

{
  for (auto & sys : _solver_systems)
    sys->needSolutionState(state, iteration_type);
  _aux->needSolutionState(state, iteration_type);
}

Referenced by FEProblemBase::createTagSolutions().

needsPreviousMultiAppFixedPointIterationAuxiliary() [1/2]

bool FEProblemBase::needsPreviousMultiAppFixedPointIterationAuxiliary ( ) const

inherited

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

{
  return _previous_multiapp_fp_aux_solution_required;
}

needsPreviousMultiAppFixedPointIterationAuxiliary() [2/2]

void FEProblemBase::needsPreviousMultiAppFixedPointIterationAuxiliary ( bool  state )

inherited

Set a flag that indicated that user required values for the previous multiapp fixed point iterate for the auxiliary system.

Definition at line 10192 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  )

inherited

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

inherited

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

{
  return _previous_multiapp_fp_nl_solution_required[solver_sys_num];
}

needsPreviousMultiSystemFixedPointIterationAuxiliary() [1/2]

bool FEProblemBase::needsPreviousMultiSystemFixedPointIterationAuxiliary ( ) const

inherited

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

{
  return _previous_multisystem_fp_aux_solution_required;
}

needsPreviousMultiSystemFixedPointIterationAuxiliary() [2/2]

void FEProblemBase::needsPreviousMultiSystemFixedPointIterationAuxiliary ( bool  state )

inherited

Set a flag that indicates that user requires values for the previous multi-system fixed point iterate for the auxiliary system.

Definition at line 10218 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  )

inherited

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

inherited

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

{
  return _previous_multisystem_fp_nl_solution_required[solver_sys_num];
}

needsPreviousNewtonIteration() [1/2]

bool FEProblemBase::needsPreviousNewtonIteration ( ) const

inherited

Check to see whether we need to compute the variable values of the previous Newton iterate.

Returns

true if the user required values of the previous Newton iterate

Definition at line 10164 of file FEProblemBase.C.

{
  return vectorTagExists(Moose::PREVIOUS_NL_SOLUTION_TAG);
}

needsPreviousNewtonIteration() [2/2]

void FEProblemBase::needsPreviousNewtonIteration ( bool  state )

inherited

Set a flag that indicated that user required values for the previous Newton iterate.

Definition at line 10170 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

inlineinherited

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

inlineinherited

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

inlineinherited

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  )

virtualinherited

Definition at line 2893 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 )

virtualinherited

Definition at line 903 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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 7779 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

overridevirtualinherited

Returns

the nonlinear system number corresponding to the provided nl_sys_name

Implements SubProblem.

Definition at line 7510 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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 7773 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  )

inherited

Definition at line 7347 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

overridevirtualinherited

Returns

the nonlocal coupling matrix for the i'th nonlinear system

Implements SubProblem.

Definition at line 10856 of file FEProblemBase.C.

{
  return _nonlocal_cm[i];
}

Referenced by DisplacedProblem::nonlocalCouplingMatrix().

notifyWhenMeshChanges()

void FEProblemBase::notifyWhenMeshChanges ( MeshChangedInterface *  mci )

inherited

Register an object that derives from MeshChangedInterface to be notified when the mesh changes.

Definition at line 9579 of file FEProblemBase.C.

{
  _notify_when_mesh_changes.push_back(mci);
}

Referenced by MeshChangedInterface::MeshChangedInterface().

notifyWhenMeshDisplaces()

void FEProblemBase::notifyWhenMeshDisplaces ( MeshDisplacedInterface *  mdi )

inherited

Register an object that derives from MeshDisplacedInterface to be notified when the displaced mesh gets updated.

Definition at line 9585 of file FEProblemBase.C.

{
  _notify_when_mesh_displaces.push_back(mdi);
}

Referenced by MeshDisplacedInterface::MeshDisplacedInterface().

numConcurrentMultiApps()

unsigned int FEProblemBase::numConcurrentMultiApps ( ) const

inlineinherited

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.

{ return _num_concurrent_multiapps; }

numGridSteps()

void FEProblemBase::numGridSteps ( unsigned int  num_grid_steps )

inlineinherited

Set the number of steps in a grid sequences.

Definition at line 2794 of file FEProblemBase.h.

{ _num_grid_steps = num_grid_steps; }

Referenced by FEProblemSolve::FEProblemSolve().

numLinearSystems()

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

inlineoverridevirtualinherited

Returns

the number of linear systems in the problem

Implements SubProblem.

Definition at line 2952 of file FEProblemBase.h.

{ return _num_linear_sys; }

Referenced by IterationAdaptiveDT::acceptStep(), FEProblemBase::addPredictor(), IterationAdaptiveDT::computeAdaptiveDT(), FEProblemSolve::FEProblemSolve(), EigenProblem::init(), Console::meshChanged(), DisplacedProblem::numLinearSystems(), Console::outputSystemInformation(), Moose::PetscSupport::petscSetDefaults(), and FEProblemBase::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.

{ 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

inlineoverridevirtualinherited

Returns

the number of nonlinear systems in the problem

Implements SubProblem.

Definition at line 2950 of file FEProblemBase.h.

{ return _num_nl_sys; }

Referenced by IterationAdaptiveDT::acceptStep(), FEProblemBase::addPredictor(), DisplacedProblem::addTimeIntegrator(), DisplacedProblem::DisplacedProblem(), Executioner::Executioner(), EigenProblem::init(), FEProblemBase::jacobianSetup(), PNGOutput::makeMeshFunc(), Console::meshChanged(), DisplacedProblem::numNonlinearSystems(), NonlinearThread::onInterfaceWithHRefinementMismatch(), ComputeBoundaryInitialConditionThread::onNode(), BoundaryElemIntegrityCheckThread::operator()(), ConsoleUtils::outputExecutionInformation(), Console::outputSystemInformation(), Moose::PetscSupport::petscSetDefaults(), ReferenceResidualConvergence::ReferenceResidualConvergence(), FEProblemBase::residualSetup(), Moose::SlepcSupport::setEigenProblemSolverParams(), Moose::PetscSupport::setLineSearchFromParams(), Moose::PetscSupport::setMFFDTypeFromParams(), FEProblemBase::setNonlinearConvergenceNames(), Moose::PetscSupport::setSolveTypeFromParams(), FEProblemSolve::solve(), FEProblemBase::solveLinearSystem(), Moose::SlepcSupport::storeSolveType(), and Console::writeVariableNorms().

numSolverSystems()

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

inlineoverridevirtualinherited

Returns

the number of solver systems in the problem

Implements SubProblem.

Definition at line 2954 of file FEProblemBase.h.

{ return _num_nl_sys + _num_linear_sys; }

Referenced by Adaptivity::adaptMesh(), Moose::PetscSupport::addPetscOptionsFromCommandline(), ElementSubdomainModifierBase::applyIC(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), EigenProblemSolve::EigenProblemSolve(), FEProblemBase::FEProblemBase(), TransientBase::getTimeIntegratorNames(), Adaptivity::init(), FixedPointSolve::initialSetup(), DisplacedProblem::numSolverSystems(), ConsoleUtils::outputExecutionInformation(), Moose::PetscSupport::petscSetDefaultKSPNormType(), Moose::PetscSupport::petscSetDefaultPCSide(), and FEProblemBase::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.

{ return getMooseApp().numThreads(); }

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

numVectorTags()

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

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 )

staticinherited

Definition at line 3853 of file FEProblemBase.h.

{
  for (T * obj_ptr : objects)
    obj_ptr->execute();
}

objectSetupHelper()

template<typename T >

void FEProblemBase::objectSetupHelper ( const std::vector< T * > &  objects, const ExecFlagType &  exec_flag  )

staticinherited

Helpers for calling the necessary setup/execute functions for the supplied objects.

Definition at line 3819 of file FEProblemBase.h.

{
  if (exec_flag == EXEC_INITIAL)
  {
    for (T * obj_ptr : objects)
      obj_ptr->initialSetup();
  }
 
  else if (exec_flag == EXEC_TIMESTEP_BEGIN)
  {
    for (const auto obj_ptr : objects)
      obj_ptr->timestepSetup();
  }
  else if (exec_flag == EXEC_SUBDOMAIN)
  {
    for (const auto obj_ptr : objects)
      obj_ptr->subdomainSetup();
  }
 
  else if (exec_flag == EXEC_NONLINEAR)
  {
    for (const auto obj_ptr : objects)
      obj_ptr->jacobianSetup();
  }
 
  else if (exec_flag == EXEC_LINEAR)
  {
    for (const auto obj_ptr : objects)
      obj_ptr->residualSetup();
  }
}

onlyAllowDefaultNonlinearConvergence()

virtual bool FEProblemBase::onlyAllowDefaultNonlinearConvergence ( ) const

inlinevirtualinherited

Returns true if an error will result if the user supplies 'nonlinear_convergence'.

Some problems are strongly tied to their convergence, and it does not make sense to use any convergence other than their default and additionally would be error-prone.

Reimplemented in ReferenceResidualProblem.

Definition at line 817 of file FEProblemBase.h.

{ return false; }

Referenced by FEProblemSolve::FEProblemSolve().

onTimestepBegin()

void FEProblemBase::onTimestepBegin ( )

overridevirtualinherited

Implements SubProblem.

Definition at line 7961 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 ( )

overridevirtualinherited

Implements SubProblem.

Reimplemented in DumpObjectsProblem.

Definition at line 7970 of file FEProblemBase.C.

{
}

Referenced by EigenExecutionerBase::init(), NonlinearEigen::init(), FixedPointSolve::solveStep(), InversePowerMethod::takeStep(), and NonlinearEigen::takeStep().

outputStep()

void FEProblemBase::outputStep ( ExecFlagType  type )

virtualinherited

Output the current step.

Will ensure that everything is in the proper state to be outputted. Then tell the OutputWarehouse to do its thing

Parameters

type	The type execution flag (see Moose.h)

Reimplemented in DumpObjectsProblem.

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

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

parameters()

const InputParameters & MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns

The parameters of the object

Definition at line 131 of file MooseBase.h.

{ return _pars; }

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

paramInfo()

template<typename... Args>

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

inherited

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

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

Definition at line 471 of file MooseBase.h.

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

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

paramWarning() [1/2]

template<typename... Args>

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

inherited

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

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

Definition at line 464 of file MooseBase.h.

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

paramWarning() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

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

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

parentOutputPositionChanged()

void FEProblemBase::parentOutputPositionChanged ( )

inherited

Calls parentOutputPositionChanged() on all sub apps.

Definition at line 5331 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 ( )

inherited

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

inlineinherited

Definition at line 2712 of file FEProblemBase.h.

{ return _petsc_option_data_base; }

Referenced by EigenProblemSolve::initialSetup(), and Moose::PetscSupport::PetscOptionsScope::PetscOptionsScope().

petscOptionsInserted()

bool & FEProblemBase::petscOptionsInserted ( )

inlineinherited

If PETSc options are already inserted.

Definition at line 2709 of file FEProblemBase.h.

{ return _is_petsc_options_inserted; }

Referenced by EigenProblemSolve::initialSetup().

possiblyRebuildGeomSearchPatches()

void FEProblemBase::possiblyRebuildGeomSearchPatches ( )

virtualinherited

Definition at line 9196 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 FEProblemBase::solve().

postExecute()

void FEProblemBase::postExecute ( )

virtualinherited

Method called at the end of the simulation.

Definition at line 6671 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 )

virtualinherited

Perform cleanup tasks after application of predictor to solution vector.

Parameters

ghosted_solution

Ghosted solution vector

Definition at line 9088 of file FEProblemBase.C.

{
}

Referenced by NonlinearSystemBase::setInitialSolution().

pRefine()

bool MFEMProblem::pRefine ( )

inlineinherited

If AMR is enabled, request (and perform if needed) p-refinement.

Definition at line 384 of file MFEMProblem.h.

{ return _problem_data.refiner && _problem_data.refiner->pRefine(); }

Referenced by MFEMProblemSolve::solve().

prepare() [1/2]

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2096 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  )

overridevirtualinherited

Implements SubProblem.

Definition at line 2140 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 )

overridevirtualinherited

Implements SubProblem.

Definition at line 2215 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 )

virtualinherited

Begin a fresh neighbor accumulation phase by sizing and zeroing the neighbor blocks.

Definition at line 2231 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  )

overridevirtualinherited

Implements SubProblem.

Definition at line 2129 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  )

overridevirtualinherited

Implements SubProblem.

Definition at line 2499 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 )

inherited

prepareMaterials()

void FEProblemBase::prepareMaterials ( const std::unordered_set< unsigned int > &  consumer_needed_mat_props, const SubdomainID  blk_id, const THREAD_ID  tid  )

inherited

Add the MooseVariables and the material properties that the current materials depend on to the dependency list.

Parameters

consumer_needed_mat_props	The material properties needed by consumer objects (other than the materials themselves)
blk_id	The subdomain ID for which we are preparing our list of needed vars and props
tid	The thread ID we are preparing the requirements for

This MUST be done after the moose variable dependency list has been set for all the other objects using the setActiveElementalMooseVariables API!

Definition at line 4552 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  )

overridevirtualinherited

Implements SubProblem.

Definition at line 2505 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 FEProblemBase::init().

prepareShapes()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2493 of file FEProblemBase.C.

{
  _assembly[tid][_current_nl_sys->number()]->copyShapes(var);
}

Referenced by ComputeUserObjectsThread::onElement().

preserveMatrixSparsityPattern()

bool FEProblemBase::preserveMatrixSparsityPattern ( ) const

inlineinherited

Will return True if the executioner in use requires preserving the sparsity pattern of the matrices being formed during the solve.

This is usually the Jacobian.

Definition at line 2468 of file FEProblemBase.h.

{ return _preserve_matrix_sparsity_pattern; };

projectFunctionOnCustomRange()

void FEProblemBase::projectFunctionOnCustomRange ( ConstElemRange &  elem_range, Number(*)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &)  func, Gradient(*)(const Point &, const libMesh::Parameters &, const std::string &, const std::string &)  func_grad, const libMesh::Parameters &  params, const std::vector< VariableName > &  target_vars  )

inherited

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

inherited

Project initial conditions for custom elem_range and bnd_node_range This is needed when elements/boundary nodes are added to a specific subdomain at an intermediate step.

Parameters

elem_range	Element range to project on
bnd_node_range	Boundary node range to project on
target_vars	Set of variable names to project ICs

Definition at line 4175 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));
      }
    }
  }
 
  // Spline node ICs may need to be evaluated indirectly.
  bool solve_for_spline_dofs = shouldSolveForSplineDofs(_mesh.getMesh());
 
  for (auto & nl : _nl)
  {
    nl->solution().close();
    if (solve_for_spline_dofs)
      solveForSplineDofs(*nl);
    nl->solution().localize(*nl->system().current_local_solution, nl->dofMap().get_send_list());
  }
 
  _aux->solution().close();
  if (solve_for_spline_dofs)
    solveForSplineDofs(*_aux);
  _aux->solution().localize(*_aux->sys().current_local_solution, _aux->dofMap().get_send_list());
}

Referenced by ElementSubdomainModifierBase::applyIC(), and ActivateElementsUserObjectBase::initSolutions().

projectSolution()

void FEProblemBase::projectSolution ( )

inherited

Definition at line 4102 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));
      }
    }
  }
 
  // Spline node ICs may need to be evaluated indirectly.
  bool solve_for_spline_dofs = shouldSolveForSplineDofs(_mesh.getMesh());
 
  for (auto & sys : _solver_systems)
  {
    sys->solution().close();
    if (solve_for_spline_dofs)
      solveForSplineDofs(*sys);
    sys->solution().localize(*sys->system().current_local_solution, sys->dofMap().get_send_list());
  }
 
  _aux->solution().close();
  if (solve_for_spline_dofs)
    solveForSplineDofs(*_aux);
  _aux->solution().localize(*_aux->sys().current_local_solution, _aux->dofMap().get_send_list());
}

Referenced by FEProblemBase::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().

rebalanceMesh()

void MFEMProblem::rebalanceMesh ( mfem::ParMesh &  pmesh )

inherited

Rebalance the (necessarily nonconforming) mesh.

Definition at line 785 of file MFEMProblem.C.

{
  if (pmesh.Nonconforming())
  {
    pmesh.Rebalance();
    updateFESpaces();
    updateGridFunctions();
  }
}

Referenced by MFEMRefinementMarker::hRefine().

registerInvalidSolutionInternal()

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

protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

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

registerRandomInterface()

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

inherited

Definition at line 10047 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 )

protectedinherited

Call when it is possible that the needs for ghosted elements has changed.

Parameters

mortar_changed

Whether an update of mortar data has been requested since the last EquationSystems (re)initialization

Definition at line 6094 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 FEProblemBase::meshChanged(), FEProblemBase::possiblyRebuildGeomSearchPatches(), and FEProblemBase::updateMortarMesh().

reinitDirac()

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

overridevirtualinherited

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

The maximum number of qps can rise if several Dirac points are added to a single element. In that case we need to resize the zeros to compensate.

Implements SubProblem.

Definition at line 2544 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  )

overridevirtualinherited

Implements SubProblem.

Definition at line 2599 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()(), FEProblemBase::reinitDirac(), and FEProblemBase::reinitElemPhys().

reinitElemFace() [1/2]

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

inherited

Definition at line 2631 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 FEProblemBase::reinitElemFace().

reinitElemFace() [2/2]

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2644 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  )

overridevirtualinherited

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

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

Reimplemented from SubProblem.

Definition at line 10437 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  )

overridevirtualinherited

Implements SubProblem.

Definition at line 2763 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  )

overridevirtualinherited

Implements SubProblem.

Definition at line 2610 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 ( )

inherited

reinitLowerDElem()

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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 2658 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 FEProblemBase::reinitElemNeighborAndLowerD().

reinitMaterials()

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

inherited

Definition at line 4583 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  )

inherited

reinit materials on a boundary

Parameters

boundary_id	The boundary on which to reinit corresponding materials
tid	The thread id
swap_stateful	Whether to swap stateful material properties between MaterialData and MaterialPropertyStorage
execute_stateful	Whether to execute material objects that have stateful properties. This should be false when for example executing material objects for mortar contexts in which stateful properties don't make sense
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4728 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(), NonlinearThread::onInterfaceWithHRefinementMismatch(), 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  )

inherited

reinit materials on element faces

Parameters

blk_id	The subdomain on which the element owning the face lives
tid	The thread id
swap_stateful	Whether to swap stateful material properties between MaterialData and MaterialPropertyStorage
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4606 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  )

inherited

reinit materials on element faces on a boundary (internal or external) This specific routine helps us not reinit when don't need to

Parameters

boundary_id	The boundary on which the face belongs
blk_id	The block id to which the element (who owns the face) belong
tid	The thread id
swap_stateful	Whether to swap stateful material properties between MaterialData and MaterialPropertyStorage
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4638 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(), NonlinearThread::onInterfaceWithHRefinementMismatch(), and NonlinearThread::prepareFace().

reinitMaterialsInterface()

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

inherited

Definition at line 4756 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(), NonlinearThread::onInterface(), and NonlinearThread::onInterfaceWithHRefinementMismatch().

reinitMaterialsNeighbor()

void FEProblemBase::reinitMaterialsNeighbor ( SubdomainID  blk_id, const THREAD_ID  tid, bool  swap_stateful = true, const std::deque< MaterialBase * > *  reinit_mats = nullptr  )

inherited

reinit materials on the neighboring element face

Parameters

blk_id	The subdomain on which the neighbor element lives
tid	The thread id
swap_stateful	Whether to swap stateful material properties between MaterialData and MaterialPropertyStorage
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4688 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(), FEProblemBase::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  )

inherited

reinit materials on neighbor element (usually faces) on a boundary (internal or external) This specific routine helps us not reinit when don't need to

Parameters

boundary_id	The boundary on which the face belongs
blk_id	The block id to which the element (who owns the face) belong
tid	The thread id
swap_stateful	Whether to swap stateful material properties between MaterialData and MaterialPropertyStorage
reinit_mats	specific list of materials to reinit. Used notably in the context of mortar with stateful elements

Definition at line 4671 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(), and NonlinearThread::onInterfaceWithHRefinementMismatch().

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  )

inherited

Call reinit on mortar user objects with matching primary boundary ID, secondary boundary ID, and displacement characteristics.

Definition at line 10706 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  )

overridevirtualinherited

Implements SubProblem.

Definition at line 2724 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 FEProblemBase::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  )

overridevirtualinherited

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

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

Reimplemented from SubProblem.

Definition at line 10452 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  )

overridevirtualinherited

Implements SubProblem.

Definition at line 2823 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  )

overridevirtualinherited

Implements SubProblem.

Definition at line 2795 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 NonlinearThread::onInterfaceWithHRefinementMismatch(), and NonlinearSystemBase::reinitNodeFace().

reinitNode()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2671 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  )

overridevirtualinherited

Implements SubProblem.

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

Referenced by NonlinearSystemBase::computeJacobianBlocks(), NonlinearSystemBase::computeNodalBCsJacobian(), NonlinearSystemBase::computeNodalBCsResidual(), NonlinearSystemBase::computeNodalBCsResidualAndJacobian(), NonlinearSystemBase::constraintJacobians(), NonlinearSystemBase::constraintResiduals(), ComputeNodalKernelBCJacobiansThread::onNode(), ComputeNodalKernelBcsThread::onNode(), NonlinearSystemBase::reinitNodeFace(), NonlinearSystemBase::setConstraintSecondaryValues(), and NonlinearSystemBase::setInitialSolution().

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 )

overridevirtualinherited

Implements SubProblem.

Definition at line 2716 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  )

overridevirtualinherited

fills the VariableValue arrays for scalar variables from the solution vector

Parameters

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

Implements SubProblem.

Definition at line 2699 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(), FEProblemBase::computeJacobianTags(), NonlinearSystemBase::computeNodalBCsJacobian(), FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), FEProblemBase::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  )

inherited

Register a MOOSE object dependency so we can either order operations properly or report when we cannot.

a -> b (a depends on b)

Definition at line 6088 of file FEProblemBase.C.

{
  //<< "Object " << a->name() << " -> " << b->name() << std::endl;
}

resetFailNextNonlinearConvergenceCheck()

void FEProblemBase::resetFailNextNonlinearConvergenceCheck ( )

inlineinherited

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

Definition at line 2995 of file FEProblemBase.h.

{ resetFailNextSystemConvergenceCheck(); }

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

resetFailNextSystemConvergenceCheck()

void FEProblemBase::resetFailNextSystemConvergenceCheck ( )

inlineinherited

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

Definition at line 2997 of file FEProblemBase.h.

{ _fail_next_system_convergence_check = false; }

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

resetState()

void FEProblemBase::resetState ( )

privatevirtualinherited

Reset state of this object in preparation for the next evaluation.

Definition at line 7699 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 FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::computeResidualTags().

residualSetup()

void FEProblemBase::residualSetup ( )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 10606 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 FEProblemBase::residualSetup(), and NonlinearSystemBase::residualSetup().

resizeMaterialData()

void FEProblemBase::resizeMaterialData ( Moose::MaterialDataType  data_type, unsigned int  nqp, const THREAD_ID  tid  )

inherited

Resize material data.

Parameters

data_type	The type of material data to resize
nqp	The number of quadrature points to resize for
tid	The thread ID

Definition at line 10523 of file FEProblemBase.C.

{
  getMaterialData(data_type, tid).resize(nqp);
}

resolveMFEMSolvers()

void MFEMEigenproblem::resolveMFEMSolvers ( )

overridevirtual

Construct recorded MFEM solvers in dependency order and select the problem driver solver(s).

Reimplemented from MFEMProblem.

Definition at line 101 of file MFEMEigenproblem.C.

{
  MFEMProblem::resolveMFEMSolvers();
 
  if (getProblemData().nonlinear_solver)
    mooseError("MFEMEigenproblem does not support nonlinear solver '",
               getProblemData().nonlinear_solver->name(),
               "'.");
 
  if (getProblemData().jacobian_solver &&
      !std::dynamic_pointer_cast<Moose::MFEM::EigensolverBase>(getProblemData().jacobian_solver))
    mooseError("The selected solver '",
               getProblemData().jacobian_solver->name(),
               "' is not an eigensolver, but the problem is marked as an eigenproblem.");
}

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

inherited

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

inherited

Restore the MultiApps associated with the ExecFlagType.

Parameters

force

Force restoration because something went wrong with the solve

Definition at line 6736 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 ( )

virtualinherited

Restore old solutions from the backup vectors and deallocate them.

Definition at line 7914 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

inlineinherited

Returns

Whether the original matrix nonzero pattern is restored before each Jacobian assembly

Definition at line 2448 of file FEProblemBase.h.

{ return _restore_original_nonzero_pattern; }

Referenced by NonlinearSystemBase::computeJacobianInternal().

restoreSolutions()

void FEProblemBase::restoreSolutions ( )

virtualinherited

Definition at line 7876 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 FEProblemBase::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.

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

{ return _safe_access_tagged_vectors; }

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

saveOldSolutions()

void FEProblemBase::saveOldSolutions ( )

virtualinherited

Allocate vectors and save old solutions into them.

Definition at line 7904 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 FEProblemBase::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 FEProblemBase::computeLinearSystemSys(), FEProblemBase::computeResidualAndJacobian(), and ComputeResidualAndJacobianThread::determineObjectWarehouses().

setActiveElementalMooseVariables()

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

overridevirtualinherited

Set the MOOSE variables to be reinited on each element.

Parameters

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

Reimplemented from SubProblem.

Definition at line 7009 of file FEProblemBase.C.

{
  SubProblem::setActiveElementalMooseVariables(moose_vars, tid);
 
  if (_displaced_problem)
    _displaced_problem->setActiveElementalMooseVariables(moose_vars, tid);
}

Referenced by FEProblemBase::prepareMaterials(), ComputeDiracThread::subdomainChanged(), ComputeIndicatorThread::subdomainChanged(), ComputeMarkerThread::subdomainChanged(), ComputeMaterialsObjectThread::subdomainChanged(), and ComputeUserObjectsThread::subdomainChanged().

setActiveFEVariableCoupleableMatrixTags()

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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6971 of file FEProblemBase.C.

{
  SubProblem::setActiveFEVariableCoupleableMatrixTags(mtags, tid);
 
  if (_displaced_problem)
    _displaced_problem->setActiveFEVariableCoupleableMatrixTags(mtags, tid);
}

setActiveFEVariableCoupleableVectorTags()

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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6980 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  )

inherited

Record and set the material properties required by the current computing thread.

Parameters

mat_prop_ids	The set of material properties required by the current computing thread.
tid	The thread id

Definition at line 7064 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(), FEProblemBase::prepareMaterials(), NodalPatchRecovery::reinitPatch(), NonlinearSystemBase::setConstraintSecondaryValues(), and ComputeDiracThread::subdomainChanged().

setActiveScalarVariableCoupleableMatrixTags()

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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6989 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  )

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 6999 of file FEProblemBase.C.

{
  SubProblem::setActiveScalarVariableCoupleableVectorTags(vtags, tid);
 
  if (_displaced_problem)
    _displaced_problem->setActiveScalarVariableCoupleableVectorTags(vtags, tid);
}

Referenced by AuxiliarySystem::setScalarVariableCoupleableTags().

setAssemblyLevel()

void MFEMProblem::setAssemblyLevel ( mfem::AssemblyLevel  assembly_level )

inlineinherited

Set the default assembly level to use for EquationSystem assembly.

Called by the MFEM executioners, which own the user-facing assembly_level parameter, during their construction; weak forms read it back when building their EquationSystems in setEquationSystems().

Definition at line 439 of file MFEMProblem.h.

{ _assembly_level = assembly_level; }

Referenced by MFEMTransient::MFEMTransient().

setAuxKernelParamsAndLog()

void FEProblemBase::setAuxKernelParamsAndLog ( const std::string &  ak_name, const std::string &  name, InputParameters &  parameters, const std::string &  base_name  )

privateinherited

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 3376 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 FEProblemBase::addAuxKernel().

setAxisymmetricCoordAxis()

void FEProblemBase::setAxisymmetricCoordAxis ( const MooseEnum &  rz_coord_axis )

inherited

Definition at line 1002 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.

{ _show_chain_control_data = set_output; }

setCheckResidualForNans()

void FEProblemBase::setCheckResidualForNans ( bool  check_residual_for_nans )

inlineinherited

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 )

inlineinherited

Set flag that Jacobian is constant (for optimization purposes)

Parameters

state

True if the Jacobian is constant, false otherwise

Definition at line 2291 of file FEProblemBase.h.

{ _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  )

inherited

Definition at line 994 of file FEProblemBase.C.

{
  TIME_SECTION("setCoordSystem", 5, "Setting Coordinate System");
  _mesh.setCoordSystem(blocks, coord_sys);
}

setCoupling()

void FEProblemBase::setCoupling ( Moose::CouplingType  type )

inherited

Set the coupling between variables TODO: allow user-defined coupling.

Parameters

type	Type of coupling

Definition at line 7240 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 FEProblemBase::init(), and Moose::SlepcSupport::setEigenProblemSolverParams().

setCouplingMatrix() [1/2]

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

inherited

setCouplingMatrix() [2/2]

void FEProblemBase::setCouplingMatrix ( std::unique_ptr< libMesh::CouplingMatrix >  cm, const unsigned int  nl_sys_num  )

inherited

Set custom coupling matrix.

Parameters

cm	coupling matrix to be set
nl_sys_num	which nonlinear system we are setting the coupling matrix for

Referenced by MoosePreconditioner::setCouplingMatrix().

setCurrentAlgebraicBndNodeRange()

void FEProblemBase::setCurrentAlgebraicBndNodeRange ( ConstBndNodeRange *  range )

inherited

Definition at line 10823 of file FEProblemBase.C.

{
  if (!range)
  {
    _current_algebraic_bnd_node_range = nullptr;
    return;
  }
 
  _current_algebraic_bnd_node_range = std::make_unique<ConstBndNodeRange>(*range);
}

setCurrentAlgebraicElementRange()

void FEProblemBase::setCurrentAlgebraicElementRange ( libMesh::ConstElemRange *  range )

inherited

These functions allow setting custom ranges for the algebraic elements, nodes, and boundary nodes that contribute to the jacobian and residual for this local processor.

setCurrentAlgebraicElementRange() sets the element range that contributes to the system. A nullptr will reset the range to use the mesh's range.

setCurrentAlgebraicNodeRange() sets the node range that contributes to the system. A nullptr will reset the range to use the mesh's range.

setCurrentAlgebraicBndNodeRange() sets the boundary node range that contributes to the system. A nullptr will reset the range to use the mesh's range.

Parameters

range

A pointer to the const range object representing the algebraic elements, nodes, or boundary nodes.

Definition at line 10801 of file FEProblemBase.C.

{
  if (!range)
  {
    _current_algebraic_elem_range = nullptr;
    return;
  }
 
  _current_algebraic_elem_range = std::make_unique<ConstElemRange>(*range);
}

setCurrentAlgebraicNodeRange()

void FEProblemBase::setCurrentAlgebraicNodeRange ( libMesh::ConstNodeRange *  range )

inherited

Definition at line 10812 of file FEProblemBase.C.

{
  if (!range)
  {
    _current_algebraic_node_range = nullptr;
    return;
  }
 
  _current_algebraic_node_range = std::make_unique<ConstNodeRange>(*range);
}

setCurrentBoundaryID()

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

overridevirtualinherited

sets the current boundary ID in assembly

Reimplemented from SubProblem.

Definition at line 10737 of file FEProblemBase.C.

{
  SubProblem::setCurrentBoundaryID(bid, tid);
  if (_displaced_problem)
    _displaced_problem->setCurrentBoundaryID(bid, tid);
}

setCurrentExecuteOnFlag()

void FEProblemBase::setCurrentExecuteOnFlag ( const ExecFlagType &  flag )

inherited

Definition at line 5430 of file FEProblemBase.C.

{
  _current_execute_on_flag = flag;
}

Referenced by FEProblemBase::execute(), MFEMProblem::execute(), and FEProblemBase::outputStep().

setCurrentLinearSystem()

void FEProblemBase::setCurrentLinearSystem ( unsigned int  sys_num )

inherited

Set the current linear system pointer.

Parameters

sys_num

The number of linear system

Definition at line 10754 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 FEProblemBase::computeLinearSystemSys(), LinearSystem::computeLinearSystemTags(), and FEProblemBase::solveLinearSystem().

setCurrentLowerDElem()

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

overridevirtualinherited

Set the current lower dimensional element.

This can be null

Reimplemented from SubProblem.

Definition at line 10728 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 FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::resetState().

setCurrentlyComputingResidual()

void FEProblemBase::setCurrentlyComputingResidual ( bool  currently_computing_residual )

finalvirtualinherited

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

Reimplemented from SubProblem.

Definition at line 10404 of file FEProblemBase.C.

{
  if (_displaced_problem)
    _displaced_problem->setCurrentlyComputingResidual(currently_computing_residual);
  _currently_computing_residual = currently_computing_residual;
}

Referenced by FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), NonlinearSystemBase::computeResidualTags(), and FEProblemBase::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 FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::resetState().

setCurrentNonlinearSystem()

void FEProblemBase::setCurrentNonlinearSystem ( const unsigned int  nl_sys_num )

inherited

Definition at line 10745 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 FEProblemBase::computeJacobian(), EigenProblem::computeJacobianAB(), FEProblemBase::computeJacobianBlocks(), EigenProblem::computeJacobianBlocks(), NonlinearSystemBase::computeJacobianInternal(), EigenProblem::computeJacobianTag(), EigenProblem::computeMatricesTags(), EigenProblem::computeResidualTag(), NonlinearSystemBase::computeResidualTags(), ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), FEProblemBase::solve(), and EigenProblem::solve().

setCurrentResidualVectorTags()

void FEProblemBase::setCurrentResidualVectorTags ( const std::set< TagID > &  vector_tags )

inlineinherited

Set the current residual vector tag data structure based on the passed in tag IDs.

Definition at line 4000 of file FEProblemBase.h.

{
  _current_residual_vector_tags = getVectorTags(vector_tags);
}

Referenced by FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), and CrankNicolson::init().

setCurrentSubdomainID()

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

overridevirtualinherited

Implements SubProblem.

Definition at line 2176 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()().

setEquationSystems()

void MFEMProblem::setEquationSystems ( )

inherited

Set all MFEM EquationSystems for this problem.

Definition at line 480 of file MFEMProblem.C.

{
  std::vector<MFEMWeakFormBase *> weak_forms;
  theWarehouse().query().condition<AttribSystem>("MFEMWeakFormBase").queryInto(weak_forms);
 
  // Add a default MFEMWeakForm if none has been added by the user.
  if (weak_forms.empty())
    weak_forms.push_back(addDefaultWeakForm().get());
 
  for (auto & weak_form : weak_forms)
    _problem_data.eqn_systems.Register(weak_form->name(), weak_form->createEquationSystem());
}

setErrorOnJacobianNonzeroReallocation()

void FEProblemBase::setErrorOnJacobianNonzeroReallocation ( bool  state )

inlineinherited

Definition at line 2459 of file FEProblemBase.h.

  {
    _error_on_jacobian_nonzero_reallocation = state;
  }

setException()

void FEProblemBase::setException ( const std::string &  message )

virtualinherited

Set an exception, which is stored at this point by toggling a member variable in this class, and which must be followed up with by a call to checkExceptionAndStopSolve().

Parameters

message

The error message describing the exception, which will get printed when checkExceptionAndStopSolve() is called

Definition at line 7629 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(), ComputeMortarFunctor::operator()(), FEProblemBase::translateCaughtException(), DisplacedProblem::updateMesh(), and DisplacedProblem::updateMesh().

setExecutionPrinting()

void FEProblemBase::setExecutionPrinting ( const ExecFlagEnum &  print_exec )

inlineinherited

Definition at line 3003 of file FEProblemBase.h.

{ _print_execution_on = print_exec; }

setFailNextNonlinearConvergenceCheck()

void FEProblemBase::setFailNextNonlinearConvergenceCheck ( )

inlineinherited

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

Definition at line 2990 of file FEProblemBase.h.

{ setFailNextSystemConvergenceCheck(); }

Referenced by Terminator::execute().

setFailNextSystemConvergenceCheck()

void FEProblemBase::setFailNextSystemConvergenceCheck ( )

inlineinherited

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

Definition at line 2992 of file FEProblemBase.h.

{ _fail_next_system_convergence_check = true; }

Referenced by FEProblemBase::setFailNextNonlinearConvergenceCheck().

setFunctorOutput()

void SubProblem::setFunctorOutput ( bool  set_output )

inlineinherited

Setter for debug functor output.

Definition at line 929 of file SubProblem.h.

{ _show_functors = set_output; }

setIgnoreZerosInJacobian()

void FEProblemBase::setIgnoreZerosInJacobian ( bool  state )

inlineinherited

Set whether the zeros in the Jacobian should be dropped from the sparsity pattern.

Definition at line 2482 of file FEProblemBase.h.

{ _ignore_zeros_in_jacobian = state; }

setInputParametersFEProblem()

virtual void FEProblemBase::setInputParametersFEProblem ( InputParameters &  parameters )

inlinevirtualinherited

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 )

inlineinherited

Set flag to indicate whether kernel coverage checks should be performed.

This check makes sure that at least one kernel is active on all subdomains in the domain (default: true).

Definition at line 2303 of file FEProblemBase.h.

  {
    _kernel_coverage_check = flag ? CoverageCheckMode::TRUE : CoverageCheckMode::FALSE;
  }

setKernelCoverageCheck() [2/2]

void FEProblemBase::setKernelCoverageCheck ( CoverageCheckMode  mode )

inlineinherited

Set flag to indicate whether kernel coverage checks should be performed.

This check makes sure that at least one kernel is active on all subdomains in the domain (default: true).

Definition at line 2297 of file FEProblemBase.h.

{ _kernel_coverage_check = mode; }

setLinearConvergenceNames()

void FEProblemBase::setLinearConvergenceNames ( const std::vector< ConvergenceName > &  convergence_names )

inherited

Sets the linear convergence object name(s) if there is one.

Definition at line 10572 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 )

inlineinherited

Set flag to indicate whether material coverage checks should be performed.

This check makes sure that at least one material is active on all subdomains in the domain if any material is supplied. If no materials are supplied anywhere, a simulation is still considered OK as long as no properties are being requested anywhere.

Definition at line 2322 of file FEProblemBase.h.

  {
    _material_coverage_check = flag ? CoverageCheckMode::TRUE : CoverageCheckMode::FALSE;
  }

setMaterialCoverageCheck() [2/2]

void FEProblemBase::setMaterialCoverageCheck ( CoverageCheckMode  mode )

inlineinherited

Set flag to indicate whether material coverage checks should be performed.

This check makes sure that at least one material is active on all subdomains in the domain if any material is supplied. If no materials are supplied anywhere, a simulation is still considered OK as long as no properties are being requested anywhere.

Definition at line 2314 of file FEProblemBase.h.

{ _material_coverage_check = mode; }

setMesh()

void MFEMProblem::setMesh ( )

inherited

Set the mesh used by MFEM.

Definition at line 109 of file MFEMProblem.C.

{
  auto pmesh = mesh().getMFEMParMeshPtr();
  getProblemData().pmesh = pmesh;
  getProblemData().comm = pmesh->GetComm();
  getProblemData().num_procs = pmesh->GetNRanks();
  getProblemData().myid = pmesh->GetMyRank();
}

Referenced by MFEMProblem::MFEMProblem().

setMultiAppFixedPointConvergenceName()

void FEProblemBase::setMultiAppFixedPointConvergenceName ( const ConvergenceName &  convergence_name )

inherited

Sets the MultiApp fixed point convergence object name if there is one.

Definition at line 10544 of file FEProblemBase.C.

{
  _multiapp_fixed_point_convergence_name = convergence_name;
}

Referenced by FixedPointSolve::FixedPointSolve().

setNeedToAddDefaultMultiAppFixedPointConvergence()

void FEProblemBase::setNeedToAddDefaultMultiAppFixedPointConvergence ( )

inlineinherited

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

inlineinherited

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

inlineinherited

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  )

virtualinherited

Definition at line 2202 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  )

overridevirtualinherited

Implements SubProblem.

Definition at line 2189 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(), NonlinearThread::onInterfaceWithHRefinementMismatch(), FEProblemBase::reinitNeighbor(), and NonlinearSystemBase::reinitNodeFace().

setNonlinearConvergenceNames()

void FEProblemBase::setNonlinearConvergenceNames ( const std::vector< ConvergenceName > &  convergence_names )

inherited

Sets the nonlinear convergence object name(s) if there is one.

Definition at line 10531 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 ( )

inherited

Set custom coupling matrix for variables requiring nonlocal contribution.

Definition at line 7281 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 )

inlineinherited

Toggle parallel barrier messaging (defaults to on).

Definition at line 2330 of file FEProblemBase.h.

{ _parallel_barrier_messaging = flag; }

setPostprocessorValueByName()

void FEProblemBase::setPostprocessorValueByName ( const PostprocessorName &  name, const PostprocessorValue &  value, std::size_t  t_index = 0  )

inherited

Set the value of a PostprocessorValue.

Parameters

name	The name of the post-processor
t_index	Flag for getting current (0), old (1), or older (2) values

Returns

The reference to the value at the given time index

Note: This method is only for setting values that already exist, the Postprocessor and PostprocessorInterface objects should be used rather than this method for creating and getting values within objects.

WARNING! This method should be used with caution. It exists to allow Transfers and other similar objects to modify Postprocessor values. It is not intended for general use.

Definition at line 5267 of file FEProblemBase.C.

{
  _reporter_data.setReporterValue<PostprocessorValue>(
      PostprocessorReporterName(name), value, t_index);
}

Referenced by PIDTransientControl::execute(), MultiAppPostprocessorTransfer::execute(), MFEMProblem::executeMFEMObjects(), PIDTransientControl::initialSetup(), FEProblemBase::joinAndFinalize(), PIDTransientControl::timestepSetup(), PicardSolve::transformPostprocessors(), SecantSolve::transformPostprocessors(), and SteffensenSolve::transformPostprocessors().

setPreserveMatrixSparsityPattern()

void FEProblemBase::setPreserveMatrixSparsityPattern ( bool  preserve )

inherited

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

This global setting can be retrieved by kernels, notably those using AD, to decide whether to take additional care to preserve the sparsity pattern

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

setProblemOperators()

void MFEMProblem::setProblemOperators ( )

inherited

Set all MFEM ProblemOperators to solve in this problem.

Definition at line 540 of file MFEMProblem.C.

{
  std::vector<MFEMProblemComposer *> problem_composers;
  theWarehouse()
      .query()
      .condition<AttribSystem>("MFEMProblemComposer")
      .queryInto(problem_composers);
 
  // Add a default MFEMProblemComposer if none has been added by the user.
  if (problem_composers.empty())
    problem_composers.push_back(addDefaultProblemComposer().get());
 
  for (auto & problem_composer : problem_composers)
    _problem_operators.push_back(problem_composer->createProblemOperator(*this));
 
  for (const auto & problem_operator : getProblemOperators())
    problem_operator->Init();
}

setResidual() [1/2]

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

pure virtualinherited

setResidual() [2/2]

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

overridevirtualinherited

Definition at line 2335 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  )

overridevirtualinherited

Definition at line 2346 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  )

privateinherited

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 3343 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 FEProblemBase::addBoundaryCondition(), FEProblemBase::addHDGKernel(), and FEProblemBase::addKernel().

setRestartFile()

void FEProblemBase::setRestartFile ( const std::string &  file_name )

inherited

Communicate to the Resurector the name of the restart filer.

Parameters

file_name

The file name for restarting from

Definition at line 10000 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::FEProblemBase().

setSNESMFReuseBase()

void FEProblemBase::setSNESMFReuseBase ( bool  reuse, bool  set_by_user  )

inlineinherited

If or not to reuse the base vector for matrix-free calculation.

Definition at line 2683 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 )

inherited

Sets the steady-state detection convergence object name if there is one.

Definition at line 10550 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 )

inlinevirtualinherited

Set boolean flag to true to store old solution second time derivative.

Definition at line 2731 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 )

inlinevirtualinherited

Set boolean flag to true to store solution second time derivative.

Definition at line 2719 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 )

inlinevirtualinherited

Set boolean flag to true to store old solution time derivative.

Definition at line 2725 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 )

inlinevirtualinherited

Set boolean flag to true to store solution time derivative.

Definition at line 2716 of file FEProblemBase.h.

{ _u_dot_requested = u_dot_requested; }

Referenced by TimeIntegrator::TimeIntegrator().

setupDampers()

void FEProblemBase::setupDampers ( )

inherited

Definition at line 6145 of file FEProblemBase.C.

{
  for (auto & nl : _nl)
    nl->setupDampers();
}

setVariableAllDoFMap()

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

inherited

Definition at line 2084 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 FEProblemBase::meshChanged().

setVectorPostprocessorValueByName()

void FEProblemBase::setVectorPostprocessorValueByName ( const std::string &  object_name, const std::string &  vector_name, const VectorPostprocessorValue &  value, std::size_t  t_index = 0  )

inherited

Set the value of a VectorPostprocessor vector.

Parameters

object_name	The name of the VPP object
vector_name	The name of the declared vector
value	The data to apply to the vector
t_index	Flag for getting current (0), old (1), or older (2) values

Definition at line 5293 of file FEProblemBase.C.

{
  _reporter_data.setReporterValue<VectorPostprocessorValue>(
      VectorPostprocessorReporterName(object_name, vector_name), value, t_index);
}

setVerboseProblem()

void FEProblemBase::setVerboseProblem ( bool  verbose )

inherited

Make the problem be verbose.

Definition at line 10720 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

inherited

Check whether the problem should output execution orders at this time.

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

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

shouldSolve()

bool FEProblemBase::shouldSolve ( ) const

inlineinherited

Definition at line 2767 of file FEProblemBase.h.

{ return _solve; }

Referenced by FEProblemSolve::solve(), MFEMProblemSolve::solve(), ExternalProblem::solve(), and TransientBase::TransientBase().

shouldUpdateSolution()

bool FEProblemBase::shouldUpdateSolution ( )

virtualinherited

Check to see whether the problem should update the solution.

Returns

true if the problem should update the solution, false otherwise

Definition at line 9075 of file FEProblemBase.C.

{
  return false;
}

Referenced by FEProblemBase::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

inlineinherited

Whether or not to print out the invalid solutions summary table in console.

Definition at line 2499 of file FEProblemBase.h.

{ return _show_invalid_solution_console; }

Referenced by SolverSystem::checkInvalidSolution().

sideUOInterfaceMatPropIntegrityCheck()

bool FEProblemBase::sideUOInterfaceMatPropIntegrityCheck ( ) const

inlineinherited

Returns

whether to perform an integrity check for side user objects consuming interface material properties

Definition at line 2850 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  )

virtualinherited

Definition at line 2537 of file FEProblemBase.C.

{
  mooseDoOnce(mooseWarning(
      "This function is deprecated and no longer performs any function. Please do not call it."));
}

skipExceptionCheck()

void FEProblemBase::skipExceptionCheck ( bool  skip_exception_check )

inlineinherited

Set a flag that indicates if we want to skip exception and stop solve.

Definition at line 2696 of file FEProblemBase.h.

  {
    _skip_exception_check = skip_exception_check;
  }

Referenced by FEProblemSolve::FEProblemSolve().

skipNextForwardSolutionCopyToOld()

void FEProblemBase::skipNextForwardSolutionCopyToOld ( )

inherited

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

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

Referenced by FullSolveMultiApp::solveStep().

solve()

void ExternalProblem::solve ( unsigned int  nl_sys_num = 0 )

finaloverridevirtualinherited

Solve is implemented to providing syncing to/from the "transfer" mesh.

Reimplemented from FEProblemBase.

Definition at line 64 of file ExternalProblem.C.

{
  TIME_SECTION("solve", 1, "Solving", false)
 
  syncSolutions(Direction::TO_EXTERNAL_APP);
  if (shouldSolve())
    externalSolve();
  syncSolutions(Direction::FROM_EXTERNAL_APP);
}

solveLinearSystem()

void FEProblemBase::solveLinearSystem ( const unsigned int  linear_sys_num, const Moose::PetscSupport::PetscOptions *  po = nullptr  )

virtualinherited

Build and solve a linear system.

Parameters

linear_sys_num	The number of the linear system (1,..,num. of lin. systems)
po	The petsc options for the solve, if not supplied, the defaults are used

Reimplemented in DumpObjectsProblem.

Definition at line 7724 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 )

inherited

Get the solver parameters.

Definition at line 10032 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(), FEProblemBase::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(), SingleMatrixPreconditioner::SingleMatrixPreconditioner(), EigenProblem::solve(), FEProblemBase::solverParams(), FEProblemBase::solverTypeString(), EigenProblem::solverTypeString(), and Moose::SlepcSupport::storeSolveType().

solverParams() [2/2]

const SolverParams & FEProblemBase::solverParams ( unsigned int  solver_sys_num = 0 ) const

inherited

const version

Definition at line 10041 of file FEProblemBase.C.

{
  return const_cast<FEProblemBase *>(this)->solverParams(solver_sys_num);
}

solverSysNum()

unsigned int FEProblemBase::solverSysNum ( const SolverSystemName &  solver_sys_name ) const

overridevirtualinherited

Returns

the solver system number corresponding to the provided solver_sys_name

Implements SubProblem.

Definition at line 7532 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 FEProblemBase::addVariable(), FEProblemBase::getSystemBase(), PhysicsBase::initializePhysics(), MultiSystemSolveObject::MultiSystemSolveObject(), and DisplacedProblem::solverSysNum().

solverSystemConverged()

bool FEProblemBase::solverSystemConverged ( const unsigned int  sys_num )

overridevirtualinherited

Returns

whether the given solver system sys_num is converged

Reimplemented from SubProblem.

Reimplemented in EigenProblem.

Definition at line 7764 of file FEProblemBase.C.

{
  if (_solve)
    return _solver_systems[sys_num]->converged();
  else
    return true;
}

solverTypeString()

std::string MFEMProblem::solverTypeString ( unsigned int  solver_sys_num )

overridevirtualinherited

Return solver type as a human readable string.

Reimplemented from FEProblemBase.

Definition at line 905 of file MFEMProblem.C.

{
  mooseAssert(solver_sys_num == 0, "All mfem systems must use the same solver right now.");
 
  std::vector<std::string> solvers;
 
  if (const auto * ns = getProblemData().nonlinear_solver.get())
    solvers.push_back(MooseUtils::prettyCppType(ns));
 
  if (const auto * js = getProblemData().jacobian_solver.get())
  {
    solvers.push_back(MooseUtils::prettyCppType(js));
    if (const std::string * pc = js->queryParam<MFEMSolverName>("preconditioner"))
      solvers.push_back(MooseUtils::prettyCppType(
          &getMFEMObject<Moose::MFEM::LinearSolverBase>("Moose::MFEM::SolverBase", *pc)));
  }
 
  return solvers.empty() ? "None" : MooseUtils::stringJoin(solvers);
}

startedInitialSetup()

virtual bool FEProblemBase::startedInitialSetup ( )

inlinevirtualinherited

Returns true if we are in or beyond the initialSetup stage.

Definition at line 569 of file FEProblemBase.h.

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

virtualinherited

Definition at line 2878 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

inlineinherited

Dimension of the subspace spanned by vectors with a given prefix.

Parameters

prefix

Prefix of the vectors spanning the subspace.

Definition at line 2372 of file FEProblemBase.h.

  {
    if (_subspace_dim.count(prefix))
      return _subspace_dim.find(prefix)->second;
    else
      return 0;
  }

Referenced by FEProblemBase::computeNearNullSpace(), FEProblemBase::computeNullSpace(), and FEProblemBase::computeTransposeNullSpace().

swapBackMaterials()

void FEProblemBase::swapBackMaterials ( const THREAD_ID  tid )

virtualinherited

Definition at line 4778 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 )

virtualinherited

Definition at line 4785 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(), NonlinearThread::onInterfaceWithHRefinementMismatch(), ComputeIndicatorThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), NonlinearThread::onInternalSide(), and ComputeElemAuxBcsThread< AuxKernelType >::operator()().

swapBackMaterialsNeighbor()

void FEProblemBase::swapBackMaterialsNeighbor ( const THREAD_ID  tid )

virtualinherited

Definition at line 4793 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(), NonlinearThread::onInterfaceWithHRefinementMismatch(), ComputeIndicatorThread::onInternalSide(), ComputeUserObjectsThread::onInternalSide(), NonlinearThread::onInternalSide(), and ComputeElemAuxBcsThread< AuxKernelType >::operator()().

syncSolutions()

virtual void MFEMProblem::syncSolutions ( Direction  direction )

inlineoverridevirtualinherited

Method to transfer data to/from the external application to the associated transfer mesh.

Implements ExternalProblem.

Definition at line 52 of file MFEMProblem.h.

{}

systemBaseAuxiliary() [1/2]

const SystemBase & FEProblemBase::systemBaseAuxiliary ( ) const

overridevirtualinherited

Return the auxiliary system object as a base class reference.

Implements SubProblem.

Definition at line 10382 of file FEProblemBase.C.

{
  return *_aux;
}

Referenced by PhysicsBase::copyVariablesFromMesh(), and MFEMProblem::getAuxVariableNames().

systemBaseAuxiliary() [2/2]

SystemBase & FEProblemBase::systemBaseAuxiliary ( )

overridevirtualinherited

Implements SubProblem.

Definition at line 10388 of file FEProblemBase.C.

{
  return *_aux;
}

systemBaseLinear() [1/2]

const SystemBase & FEProblemBase::systemBaseLinear ( unsigned int  sys_num ) const

overridevirtualinherited

Get a constant base class reference to a linear system.

Parameters

sys_num

The number of the linear system

Implements SubProblem.

Definition at line 10350 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _linear_systems.size(),
              "System number greater than the number of linear systems");
  return *_linear_systems[sys_num];
}

systemBaseLinear() [2/2]

SystemBase & FEProblemBase::systemBaseLinear ( unsigned int  sys_num )

overridevirtualinherited

Get a non-constant base class reference to a linear system.

Parameters

sys_num

The number of the linear system

Implements SubProblem.

Definition at line 10358 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _linear_systems.size(),
              "System number greater than the number of linear systems");
  return *_linear_systems[sys_num];
}

systemBaseNonlinear() [1/2]

const SystemBase & FEProblemBase::systemBaseNonlinear ( const unsigned int  sys_num ) const

overridevirtualinherited

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

Implements SubProblem.

Definition at line 10336 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
  return *_nl[sys_num];
}

systemBaseNonlinear() [2/2]

SystemBase & FEProblemBase::systemBaseNonlinear ( const unsigned int  sys_num )

overridevirtualinherited

Implements SubProblem.

Definition at line 10343 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _nl.size(), "System number greater than the number of nonlinear systems");
  return *_nl[sys_num];
}

systemBaseSolver() [1/2]

const SystemBase & FEProblemBase::systemBaseSolver ( const unsigned int  sys_num ) const

overridevirtualinherited

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

Implements SubProblem.

Definition at line 10366 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _solver_systems.size(),
              "System number greater than the number of solver systems");
  return *_solver_systems[sys_num];
}

systemBaseSolver() [2/2]

SystemBase & FEProblemBase::systemBaseSolver ( const unsigned int  sys_num )

overridevirtualinherited

Implements SubProblem.

Definition at line 10374 of file FEProblemBase.C.

{
  mooseAssert(sys_num < _solver_systems.size(),
              "System number greater than the number of solver systems");
  return *_solver_systems[sys_num];
}

systemNumForVariable()

unsigned int FEProblemBase::systemNumForVariable ( const VariableName &  variable_name ) const

inherited

Returns

the system number for the provided variable_name Can be nonlinear or auxiliary

Definition at line 7552 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 FEProblemBase::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.

{ _termination_requested = true; };

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

theWarehouse()

TheWarehouse & FEProblemBase::theWarehouse ( ) const

inlineinherited

Definition at line 2678 of file FEProblemBase.h.

{ return _app.theWarehouse(); }

Referenced by NonlinearSystemBase::addBoundaryCondition(), NonlinearSystemBase::addDGKernel(), NonlinearSystemBase::addDiracKernel(), FEProblemBase::addFVGradientMethod(), FEProblemBase::addFVInterpolationMethod(), NonlinearSystemBase::addHDGKernel(), NonlinearSystemBase::addInterfaceKernel(), NonlinearSystemBase::addKernel(), NonlinearSystemBase::addNodalKernel(), FEProblemBase::addObject(), NonlinearSystemBase::addScalarKernel(), NonlinearSystemBase::addSplit(), FEProblemBase::addUserObject(), FEProblemBase::checkGradientMethods(), NonlinearSystemBase::checkKernelCoverage(), FEProblemBase::checkUserObjectJacobianRequirement(), FEProblemBase::checkUserObjects(), NonlinearSystemBase::computeJacobianInternal(), ComputeJacobianThread::computeOnInternalFace(), NonlinearSystemBase::computeResidualAndJacobianInternal(), NonlinearSystemBase::computeResidualInternal(), LinearSystem::containsTimeKernel(), FEProblemBase::customSetup(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), ComputeResidualThread::determineObjectWarehouses(), MFEMProblem::executeMFEMObjects(), FEProblemBase::executeSamplers(), ComputeLinearFVElementalThread::fetchBlockSystemContributionObjects(), ComputeLinearFVFaceThread::fetchBlockSystemContributionObjects(), FEProblemBase::getDistribution(), FEProblemBase::getFVGradientMethod(), FEProblemBase::getFVInterpolationMethod(), NonlinearSystemBase::getFVSetupObjects(), FEProblemBase::getKokkosUserObject(), MFEMProblem::getMFEMObject(), FEProblemBase::getMortarUserObjects(), FEProblemBase::getPositionsObject(), FEProblemBase::getPostprocessorObjectByName(), FEProblemBase::getSampler(), CompositionDT::getTimeSteppers(), FEProblemBase::getUOQuery(), FEProblemBase::getUserObject(), FEProblemBase::getUserObjectBase(), FEProblemBase::getVectorPostprocessorObjectByName(), FEProblemBase::hasDistribution(), FEProblemBase::hasFVGradientMethod(), FEProblemBase::hasFVInterpolationMethod(), MFEMProblem::hasMFEMObject(), FEProblemBase::hasUserObject(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), MFEMProblem::initialSetup(), BoundaryLinearFVFluxIntegral::initialSetup(), SideFVFluxBCIntegral::initialSetup(), LinearSystem::initialSetup(), ExplicitTimeIntegrator::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), FEProblemBase::needBoundaryMaterialOnSide(), FEProblemBase::needInterfaceMaterialOnSide(), FEProblemBase::needInternalNeighborSideMaterial(), JSONOutput::outputReporters(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), MFEMProblem::setEquationSystems(), MFEMProblem::setProblemOperators(), ComputeLinearFVElementalThread::setupSystemContributionObjects(), ComputeLinearFVFaceThread::setupSystemContributionObjects(), and FEProblemBase::timestepSetup().

time()

virtual Real & FEProblemBase::time ( ) const

inlinevirtualinherited

Definition at line 574 of file FEProblemBase.h.

{ return _time; }

Referenced by EigenExecutionerBase::EigenExecutionerBase(), PseudoTimestep::execute(), Times::getCurrentTime(), FEProblemBase::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() ? section_name : _prefix + "::" + section_name;
}

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

timeOld()

virtual Real & FEProblemBase::timeOld ( ) const

inlinevirtualinherited

Definition at line 575 of file FEProblemBase.h.

{ return _time_old; }

Referenced by EigenExecutionerBase::EigenExecutionerBase(), FEProblemBase::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

inlinevirtualinherited

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.

{ return _time_older; }

Referenced by FEProblemBase::getTimeFromStateArg().

timeStep()

virtual int & FEProblemBase::timeStep ( ) const

inlinevirtualinherited

Definition at line 583 of file FEProblemBase.h.

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

overridevirtualinherited

Reimplemented from SubProblem.

Definition at line 1877 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 )

inlinevirtualinherited

Definition at line 591 of file FEProblemBase.h.

{ _transient = trans; }

Referenced by EigenExecutionerBase::EigenExecutionerBase(), and TransientBase::TransientBase().

translateCaughtException()

void FEProblemBase::translateCaughtException ( const std::string &  calling_method )

privateinherited

Classify the exception currently being handled and register its message with setException(), or error if the exception cannot be recovered from.

Must be called from within a catch block. This does not communicate, so every rank must subsequently call checkExceptionAndStopSolve(). A MooseHandledException has already been communicated and is rethrown unchanged.

Definition at line 8370 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 MooseHandledException &)
  {
    // Already communicated to all processes and the solve has been stopped
    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);
    }
  }
}

Referenced by FEProblemBase::handleException(), and FEProblemBase::translateUserObjectExceptions().

translateUserObjectExceptions()

void FEProblemBase::translateUserObjectExceptions ( const std::function< void()> &  work )

privateinherited

Execute work, user object computations local to this process, and register any exception it raises with translateCaughtException() instead of letting it propagate, so that this process does not skip communication entered by the other processes.

Every process must subsequently call checkExceptionAndStopSolve().

Definition at line 8435 of file FEProblemBase.C.

{
  try
  {
    work();
  }
  catch (...)
  {
    translateCaughtException("computeUserObjectsInternal");
  }
}

Referenced by FEProblemBase::computeUserObjectsInternal(), and FEProblemBase::joinAndFinalize().

trustUserCouplingMatrix()

void FEProblemBase::trustUserCouplingMatrix ( )

inherited

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

See https://github.com/idaholab/moose/issues/16395 for detailed background

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

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

typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

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

Returns

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

Definition at line 57 of file MooseBase.C.

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

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

uDotDotOldRequested()

virtual bool FEProblemBase::uDotDotOldRequested ( )

inlinevirtualinherited

Get boolean flag to check whether old solution second time derivative needs to be stored.

Definition at line 2754 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 ( )

inlinevirtualinherited

Get boolean flag to check whether solution second time derivative needs to be stored.

Definition at line 2740 of file FEProblemBase.h.

{ return _u_dotdot_requested; }

Referenced by SystemBase::addDotVectors(), and FEProblemBase::addTimeIntegrator().

uDotOldRequested()

virtual bool FEProblemBase::uDotOldRequested ( )

inlinevirtualinherited

Get boolean flag to check whether old solution time derivative needs to be stored.

Definition at line 2743 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 ( )

inlinevirtualinherited

Get boolean flag to check whether solution time derivative needs to be stored.

Definition at line 2737 of file FEProblemBase.h.

{ return _u_dot_requested; }

Referenced by SystemBase::addDotVectors().

uniformRefine()

void FEProblemBase::uniformRefine ( )

inherited

uniformly refine the problem mesh(es).

This will also prolong the the solution, and in order for that to be safe, we can only perform one refinement at a time

Definition at line 10412 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 ( )

virtualinherited

Update the active objects in the warehouses.

Reimplemented in DumpObjectsProblem.

Definition at line 6057 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().

updateFESpaces()

void MFEMProblem::updateFESpaces ( )

inherited

Calls Update() on all FE spaces.

Definition at line 796 of file MFEMProblem.C.

{
  for (const auto & fe_space_pair : _problem_data.fespaces)
    fe_space_pair.second->Update();
}

Referenced by MFEMRefinementMarker::hRefine(), and MFEMProblem::rebalanceMesh().

updateGeomSearch()

void FEProblemBase::updateGeomSearch ( GeometricSearchData::GeometricSearchType  type = GeometricSearchData::ALL )

overridevirtualinherited

Update this object's geometric search data as well as the displaced problem's if it exists.

Implements SubProblem.

Definition at line 9102 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().

updateGridFunctions()

void MFEMProblem::updateGridFunctions ( )

inherited

Calls Update() on all gridfunctions.

Definition at line 803 of file MFEMProblem.C.

{
  for (const auto & gridfunction_pair : _problem_data.gridfunctions)
    gridfunction_pair.second->Update();
}

Referenced by MFEMRefinementMarker::hRefine(), MFEMRefinementMarker::pRefine(), and MFEMProblem::rebalanceMesh().

updateMaxQps()

void FEProblemBase::updateMaxQps ( )

privateinherited

Definition at line 7139 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 FEProblemBase::bumpAllQRuleOrder(), FEProblemBase::bumpVolumeQRuleOrder(), and FEProblemBase::createQRules().

updateMeshXFEM()

bool FEProblemBase::updateMeshXFEM ( )

virtualinherited

Update the mesh due to changing XFEM cuts.

Definition at line 9384 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 ( )

virtualinherited

Definition at line 9113 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 FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), and FEProblemBase::init().

updateSolution()

bool FEProblemBase::updateSolution ( NumericVector< libMesh::Number > &  vec_solution, NumericVector< libMesh::Number > &  ghosted_solution  )

virtualinherited

Update the solution.

Parameters

vec_solution	Local solution vector that gets modified by this method
ghosted_solution	Ghosted solution vector

Returns

true if the solution was modified, false otherwise

Definition at line 9081 of file FEProblemBase.C.

{
  return false;
}

Referenced by FEProblemBase::computePostCheck().

useHashTableMatrixAssembly()

bool FEProblemBase::useHashTableMatrixAssembly ( ) const

inlineinherited

Definition at line 3088 of file FEProblemBase.h.

{ return _use_hash_table_matrix_assembly; }

Referenced by NonlinearSystemBase::addConstraint().

useSNESMFReuseBase()

bool FEProblemBase::useSNESMFReuseBase ( )

inlineinherited

Return a flag that indicates if we are reusing the vector base.

Definition at line 2691 of file FEProblemBase.h.

{ return _snesmf_reuse_base; }

Referenced by NonlinearSystem::potentiallySetupFiniteDifferencing().

validateVariableNumericType()

void MFEMProblem::validateVariableNumericType ( const std::string &  var_type, const std::string &  var_name  ) const

protectedinherited

Verify that a primary variable's numeric type matches the problem's equation system.

Definition at line 298 of file MFEMProblem.C.

{
  const bool variable_is_complex = var_type == "MFEMComplexVariable";
  const bool problem_is_complex = _num_type == NumericType::COMPLEX;
  if (variable_is_complex != problem_is_complex)
    paramError("numeric_type",
               "The problem numeric type does not match primary MFEM variable '",
               var_name,
               "', which is ",
               variable_is_complex ? "complex." : "real.");
}

Referenced by addVariable(), and MFEMProblem::addVariable().

validParams()

InputParameters MFEMEigenproblem::validParams ( )

static

Definition at line 20 of file MFEMEigenproblem.C.

{
  InputParameters params = MFEMProblem::validParams();
  params.addClassDescription("Problem type for building and solving a finite element eigenproblem "
                             "using the MFEM finite element library.");
  params.addParam<int>("num_modes", 1, "Set the number of lowest eigenmodes to compute.");
  params.addParam<std::string>(
      "mode_separator",
      "_",
      "Separator string inserted between a variable name and its eigenmode index when "
      "registering the gridfunction that stores the corresponding eigenvector.");
  params.addParam<MFEMScalarCoefficientName>(
      "rhs_coefficient",
      "1.",
      "Name of the coefficient to scale the right-hand side of the eigenproblem equation by.");
  params.addParam<MFEMMatrixCoefficientName>("rhs_matrix_coefficient",
                                             "Name of the matrix coefficient to scale the "
                                             "right-hand side of the eigenproblem equation by.");
 
  return params;
}

vectorTagExists() [1/2]

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

inlinevirtualinherited

Check to see if a particular Tag exists.

Reimplemented in DisplacedProblem.

Definition at line 204 of file SubProblem.h.

{ return tag_id < _vector_tags.size(); }

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

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

inlineinherited

Whether or not to use verbose printing for MultiApps.

Definition at line 2338 of file FEProblemBase.h.

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

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(), PhysicsBase::addSharedAuxVariable(), PhysicsBase::addSharedSolverVariable(), 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

inherited

Definition at line 2623 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_ad_second_zero

std::vector<MooseArray<ADRealTensorValue> > FEProblemBase::_ad_second_zero

inherited

Definition at line 2626 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_ad_zero

std::vector<MooseArray<ADReal> > FEProblemBase::_ad_zero

inherited

Definition at line 2621 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_adaptivity

Adaptivity FEProblemBase::_adaptivity

protectedinherited

Definition at line 3441 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptivity(), FEProblemBase::adaptMesh(), FEProblemBase::addAnyRedistributers(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::computeMarkers(), FEProblemBase::hasInitialAdaptivity(), and FEProblemBase::initialAdaptMesh().

_all_materials

MaterialWarehouse FEProblemBase::_all_materials

protectedinherited

Definition at line 3334 of file FEProblemBase.h.

Referenced by FEProblemBase::addFunctorMaterial(), FEProblemBase::addMaterialHelper(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::computeBounds(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::customSetup(), FEProblemBase::getMaterial(), FEProblemBase::getMaterialWarehouse(), FEProblemBase::neighborSubdomainSetup(), FEProblemBase::prepareMaterials(), FEProblemBase::setActiveMaterialProperties(), FEProblemBase::subdomainSetup(), FEProblemBase::timestepSetup(), and FEProblemBase::updateActiveObjects().

_allow_ics_during_restart

const bool FEProblemBase::_allow_ics_during_restart

privateinherited

Definition at line 3717 of file FEProblemBase.h.

Referenced by FEProblemBase::checkICRestartError().

_allow_invalid_solution

const bool FEProblemBase::_allow_invalid_solution

privateinherited

Definition at line 3720 of file FEProblemBase.h.

Referenced by FEProblemBase::allowInvalidSolution().

_app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

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

_assembly

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

protectedinherited

The Assembly objects.

The first index corresponds to the thread ID and the second index corresponds to the nonlinear system number

Definition at line 3284 of file FEProblemBase.h.

Referenced by FEProblemBase::addCachedResidualDirectly(), FEProblemBase::addJacobian(), FEProblemBase::addJacobianBlockTags(), FEProblemBase::addJacobianLowerD(), FEProblemBase::addJacobianNeighbor(), FEProblemBase::addJacobianNeighborLowerD(), FEProblemBase::addJacobianOffDiagScalar(), FEProblemBase::addJacobianScalar(), FEProblemBase::addResidual(), FEProblemBase::addResidualLower(), FEProblemBase::addResidualNeighbor(), FEProblemBase::addResidualScalar(), FEProblemBase::assembly(), FEProblemBase::assembly(), FEProblemBase::bumpAllQRuleOrder(), FEProblemBase::bumpVolumeQRuleOrder(), FEProblemBase::couplingEntries(), FEProblemBase::createQRules(), FEProblemBase::fieldScalarCouplingEntries(), FEProblemBase::init(), FEProblemBase::initElementStatefulProps(), FEProblemBase::initXFEM(), FEProblemBase::meshChanged(), FEProblemBase::newAssemblyArray(), FEProblemBase::nonlocalCouplingEntries(), FEProblemBase::prepare(), FEProblemBase::prepare(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareAssemblyNeighbor(), FEProblemBase::prepareFaceShapes(), FEProblemBase::prepareNeighborShapes(), FEProblemBase::prepareShapes(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElemFace(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitElemPhys(), FEProblemBase::reinitMaterials(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsInterface(), FEProblemBase::reinitMaterialsNeighbor(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNeighborPhys(), FEProblemBase::reinitNeighborPhys(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::reinitOffDiagScalars(), FEProblemBase::reinitScalars(), FEProblemBase::setCurrentSubdomainID(), FEProblemBase::setNeighborSubdomainID(), FEProblemBase::setNeighborSubdomainID(), FEProblemBase::setResidual(), FEProblemBase::setResidualNeighbor(), FEProblemBase::swapBackMaterials(), FEProblemBase::swapBackMaterialsFace(), and FEProblemBase::swapBackMaterialsNeighbor().

_assembly_level

mfem::AssemblyLevel MFEMProblem::_assembly_level {mfem::AssemblyLevel::LEGACY}

protectedinherited

Default assembly level to use for EquationSystem assembly.

Defaults to the same level as the assembly_level parameter shared by the MFEM executioners, so that the value is well-defined even if no MFEM executioner is in use.

Definition at line 490 of file MFEMProblem.h.

{mfem::AssemblyLevel::LEGACY};

Referenced by MFEMProblem::assemblyLevel(), and MFEMProblem::setAssemblyLevel().

_aux

std::shared_ptr<AuxiliarySystem> FEProblemBase::_aux

protectedinherited

The auxiliary system.

Definition at line 3267 of file FEProblemBase.h.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxKernel(), FEProblemBase::addAuxScalarKernel(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addIndicator(), FEProblemBase::addMarker(), FEProblemBase::addMultiApp(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::advanceState(), FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::computeBounds(), FEProblemBase::computeIndicators(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeMarkers(), FEProblemBase::computePostCheck(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::computeSystems(), FEProblemBase::computeUserObjectsInternal(), FEProblemBase::copySolutionsBackwards(), FEProblemBase::createQRules(), FEProblemBase::createTagMatrices(), FEProblemBase::createTagSolutions(), FEProblemBase::customSetup(), FEProblemBase::determineSolverSystem(), DumpObjectsProblem::DumpObjectsProblem(), FEProblemBase::duplicateVariableCheck(), EigenProblem::EigenProblem(), FEProblemBase::execute(), ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), FEProblemBase::getActualFieldVariable(), FEProblemBase::getArrayVariable(), FEProblemBase::getAuxiliarySystem(), FEProblemBase::getScalarVariable(), FEProblemBase::getStandardVariable(), FEProblemBase::getSystem(), FEProblemBase::getSystemBase(), FEProblemBase::getSystemBase(), FEProblemBase::getSystemBase(), FEProblemBase::getVariable(), FEProblemBase::getVariableNames(), FEProblemBase::getVectorVariable(), FEProblemBase::hasScalarVariable(), FEProblemBase::hasSolutionState(), FEProblemBase::hasVariable(), FEProblemBase::init(), FEProblemBase::meshChanged(), FEProblemBase::needBoundaryMaterialOnSide(), FEProblemBase::needSolutionState(), FEProblemBase::outputStep(), FEProblemBase::prepare(), FEProblemBase::prepare(), FEProblemBase::prepareFace(), FEProblemBase::projectInitialConditionOnCustomRange(), FEProblemBase::projectSolution(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElem(), FEProblemBase::reinitElemFace(), FEProblemBase::reinitElemPhys(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNeighborPhys(), FEProblemBase::reinitNeighborPhys(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::reinitScalars(), FEProblemBase::restoreOldSolutions(), FEProblemBase::restoreSolutions(), FEProblemBase::saveOldSolutions(), FEProblemBase::setAuxKernelParamsAndLog(), FEProblemBase::skipNextForwardSolutionCopyToOld(), FEProblemBase::systemBaseAuxiliary(), FEProblemBase::systemBaseAuxiliary(), FEProblemBase::systemNumForVariable(), FEProblemBase::timestepSetup(), FEProblemBase::updateActiveObjects(), and FEProblemBase::updateMeshXFEM().

_aux_evaluable_local_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_aux_evaluable_local_elem_range

protectedinherited

Definition at line 3598 of file FEProblemBase.h.

_between_multi_app_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_between_multi_app_transfers

protectedinherited

Transfers executed just before MultiApps to transfer data between them.

Definition at line 3369 of file FEProblemBase.h.

Referenced by FEProblemBase::addTransfer(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::getMultiAppTransferWarehouse(), FEProblemBase::getTransfers(), FEProblemBase::getTransfers(), and FEProblemBase::updateActiveObjects().

_block_mat_side_cache

std::vector<std::unordered_map<SubdomainID, bool> > FEProblemBase::_block_mat_side_cache

protectedinherited

Cache for calculating materials on side.

Definition at line 3378 of file FEProblemBase.h.

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

_bnd_mat_side_cache

std::vector<std::unordered_map<BoundaryID, bool> > FEProblemBase::_bnd_mat_side_cache

protectedinherited

Cache for calculating materials on side.

Definition at line 3381 of file FEProblemBase.h.

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

_bnd_material_props

MaterialPropertyStorage& FEProblemBase::_bnd_material_props

protectedinherited

Definition at line 3321 of file FEProblemBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), FEProblemBase::advanceState(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::getBndMaterialPropertyStorage(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), FEProblemBase::initElementStatefulProps(), FEProblemBase::initXFEM(), FEProblemBase::meshChanged(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsInterface(), and FEProblemBase::swapBackMaterialsFace().

_boundary_restricted_elem_integrity_check

const bool FEProblemBase::_boundary_restricted_elem_integrity_check

protectedinherited

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

whether the variable dependencies are defined on the selected boundaries

Definition at line 3523 of file FEProblemBase.h.

_boundary_restricted_node_integrity_check

const bool FEProblemBase::_boundary_restricted_node_integrity_check

protectedinherited

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

whether the variable dependencies are defined on the selected boundaries

Definition at line 3519 of file FEProblemBase.h.

_calculate_jacobian_in_uo

bool FEProblemBase::_calculate_jacobian_in_uo

protectedinherited

Definition at line 3504 of file FEProblemBase.h.

Referenced by FEProblemBase::checkNonlocalCoupling(), FEProblemBase::checkUserObjectJacobianRequirement(), and FEProblemBase::meshChanged().

_check_residual_for_nans

bool FEProblemBase::_check_residual_for_nans

protectedinherited

Whether to check the residual for NaN or Inf values.

Definition at line 3549 of file FEProblemBase.h.

Referenced by FEProblemBase::checkResidualForNans(), and FEProblemBase::setCheckResidualForNans().

_checking_uo_aux_state

bool FEProblemBase::_checking_uo_aux_state = false

privateinherited

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

Definition at line 3766 of file FEProblemBase.h.

Referenced by FEProblemBase::checkingUOAuxState(), and FEProblemBase::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

protectedinherited

Coupling matrix for variables.

Definition at line 3270 of file FEProblemBase.h.

Referenced by FEProblemBase::areCoupled(), FEProblemBase::couplingMatrix(), FEProblemBase::FEProblemBase(), and FEProblemBase::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(), FEProblemBase::computingNonlinearResid(), and SubProblem::computingNonlinearResid().

_computing_scaling_jacobian

bool FEProblemBase::_computing_scaling_jacobian = false

privateinherited

Flag used to indicate whether we are computing the scaling Jacobian.

Definition at line 3760 of file FEProblemBase.h.

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

_computing_scaling_residual

bool FEProblemBase::_computing_scaling_residual = false

privateinherited

Flag used to indicate whether we are computing the scaling Residual.

Definition at line 3763 of file FEProblemBase.h.

Referenced by FEProblemBase::computingScalingResidual(), and FEProblemBase::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.

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

_const_jacobian

bool FEProblemBase::_const_jacobian

protectedinherited

true if the Jacobian is constant

Definition at line 3483 of file FEProblemBase.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::constJacobian(), FEProblemBase::prepare(), and FEProblemBase::setConstJacobian().

_constant_null_space_vars

const std::vector<VariableName> FEProblemBase::_constant_null_space_vars

protectedinherited

Variables whose constant fields span part of the Jacobian nullspace.

Definition at line 3612 of file FEProblemBase.h.

Referenced by FEProblemBase::computeNullSpace().

_constant_transpose_null_space_vars

const std::vector<VariableName> FEProblemBase::_constant_transpose_null_space_vars

protectedinherited

Variables whose constant fields span part of the Jacobian transpose nullspace.

Definition at line 3614 of file FEProblemBase.h.

Referenced by FEProblemBase::computeTransposeNullSpace().

_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

protectedinherited

The control logic warehouse.

Definition at line 3583 of file FEProblemBase.h.

Referenced by FEProblemBase::executeControls(), FEProblemBase::getControlWarehouse(), FEProblemBase::timestepSetup(), and FEProblemBase::updateActiveObjects().

_convergences

MooseObjectWarehouse<Convergence> FEProblemBase::_convergences

protectedinherited

convergence warehouse

Definition at line 3303 of file FEProblemBase.h.

Referenced by FEProblemBase::addConvergence(), FEProblemBase::getConvergence(), FEProblemBase::getConvergenceObjects(), and FEProblemBase::hasConvergence().

_coupling

Moose::CouplingType FEProblemBase::_coupling

protectedinherited

Type of variable coupling.

Definition at line 3269 of file FEProblemBase.h.

Referenced by FEProblemBase::coupling(), FEProblemBase::init(), FEProblemBase::setCoupling(), and FEProblemBase::trustUserCouplingMatrix().

_current_algebraic_bnd_node_range

std::unique_ptr<ConstBndNodeRange> FEProblemBase::_current_algebraic_bnd_node_range

protectedinherited

Definition at line 3602 of file FEProblemBase.h.

Referenced by FEProblemBase::getCurrentAlgebraicBndNodeRange(), and FEProblemBase::setCurrentAlgebraicBndNodeRange().

_current_algebraic_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_current_algebraic_elem_range

protectedinherited

Definition at line 3600 of file FEProblemBase.h.

Referenced by FEProblemBase::getCurrentAlgebraicElementRange(), and FEProblemBase::setCurrentAlgebraicElementRange().

_current_algebraic_node_range

std::unique_ptr<libMesh::ConstNodeRange> FEProblemBase::_current_algebraic_node_range

protectedinherited

Definition at line 3601 of file FEProblemBase.h.

Referenced by FEProblemBase::getCurrentAlgebraicNodeRange(), and FEProblemBase::setCurrentAlgebraicNodeRange().

_current_execute_on_flag

ExecFlagType FEProblemBase::_current_execute_on_flag

protectedinherited

Current execute_on flag.

Definition at line 3580 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computePostCheck(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::computeUserObjectByName(), FEProblemBase::computeUserObjects(), FEProblemBase::getCurrentExecuteOnFlag(), FEProblemBase::joinAndFinalize(), FEProblemBase::resetState(), FEProblemBase::setCurrentExecuteOnFlag(), and FEProblemBase::shouldPrintExecution().

_current_ic_state

unsigned short FEProblemBase::_current_ic_state

protectedinherited

Definition at line 3609 of file FEProblemBase.h.

Referenced by FEProblemBase::getCurrentICState().

_current_linear_sys

LinearSystem* FEProblemBase::_current_linear_sys

protectedinherited

The current linear system that we are solving.

Definition at line 3231 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::computeLinearSystemSys(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualL2Norm(), FEProblemBase::currentLinearSystem(), FEProblemBase::currentLinearSystem(), FEProblemBase::setCurrentLinearSystem(), and FEProblemBase::solveLinearSystem().

_current_nl_sys

NonlinearSystemBase* FEProblemBase::_current_nl_sys

protectedinherited

The current nonlinear system that we are solving.

Definition at line 3249 of file FEProblemBase.h.

Referenced by FEProblemBase::addCachedResidualDirectly(), FEProblemBase::addJacobian(), FEProblemBase::addJacobianBlockTags(), FEProblemBase::addJacobianLowerD(), FEProblemBase::addJacobianNeighbor(), FEProblemBase::addJacobianNeighborLowerD(), FEProblemBase::addJacobianOffDiagScalar(), FEProblemBase::addJacobianScalar(), FEProblemBase::addResidual(), FEProblemBase::addResidualLower(), FEProblemBase::addResidualNeighbor(), FEProblemBase::addResidualScalar(), FEProblemBase::appendConstantModes(), FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::computeBounds(), FEProblemBase::computeDamping(), FEProblemBase::computeJacobianBlock(), FEProblemBase::computeJacobianBlocks(), EigenProblem::computeJacobianBlocks(), FEProblemBase::computeJacobianInternal(), FEProblemBase::computeJacobianTag(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeNearNullSpace(), FEProblemBase::computeNullSpace(), FEProblemBase::computePostCheck(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualInternal(), FEProblemBase::computeResidualL2Norm(), FEProblemBase::computeResidualTag(), FEProblemBase::computeResidualTags(), FEProblemBase::computeResidualType(), FEProblemBase::computeTransposeNullSpace(), FEProblemBase::currentNonlinearSystem(), FEProblemBase::currentNonlinearSystem(), EigenProblem::doFreeNonlinearPowerIterations(), EigenProblem::EigenProblem(), FEProblemBase::prepare(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareAssemblyNeighbor(), FEProblemBase::prepareFaceShapes(), FEProblemBase::prepareNeighborShapes(), FEProblemBase::prepareShapes(), FEProblemBase::reinitDirac(), FEProblemBase::reinitNeighborPhys(), FEProblemBase::reinitNeighborPhys(), FEProblemBase::reinitOffDiagScalars(), FEProblemBase::setCurrentNonlinearSystem(), FEProblemBase::setResidual(), FEProblemBase::setResidualNeighbor(), FEProblemBase::solve(), and EigenProblem::solve().

_current_residual_vector_tags

std::vector<VectorTag> FEProblemBase::_current_residual_vector_tags

privateinherited

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

Referenced by FEProblemBase::clearCurrentResidualVectorTags(), FEProblemBase::currentResidualVectorTags(), and FEProblemBase::setCurrentResidualVectorTags().

_current_solver_sys

SolverSystem* FEProblemBase::_current_solver_sys

protectedinherited

The current solver system.

Definition at line 3252 of file FEProblemBase.h.

Referenced by FEProblemBase::setCurrentLinearSystem(), and FEProblemBase::setCurrentNonlinearSystem().

_currently_computing_jacobian

bool SubProblem::_currently_computing_jacobian

protectedinherited

Flag to determine whether the problem is currently computing Jacobian.

Definition at line 1097 of file SubProblem.h.

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

_currently_computing_residual

bool SubProblem::_currently_computing_residual

protectedinherited

Whether the residual is being evaluated.

Definition at line 1106 of file SubProblem.h.

Referenced by SubProblem::currentlyComputingResidual(), FEProblemBase::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

protectedinherited

Definition at line 3442 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::getNumCyclesCompleted(), and FEProblemBase::initialAdaptMesh().

_default_ghosting

bool SubProblem::_default_ghosting

protectedinherited

Whether or not to use default libMesh coupling.

Definition at line 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(), FEProblemBase::clearDiracInfo(), SubProblem::diracKernelInfo(), DisplacedProblem::getDiracElements(), FEProblemBase::getDiracElements(), FEProblemBase::meshChanged(), DisplacedProblem::reinitDirac(), FEProblemBase::reinitDirac(), DisplacedProblem::updateMesh(), and DisplacedProblem::updateMesh().

_discrete_materials

MaterialWarehouse FEProblemBase::_discrete_materials

protectedinherited

Definition at line 3333 of file FEProblemBase.h.

Referenced by FEProblemBase::addMaterialHelper(), FEProblemBase::getDiscreteMaterialWarehouse(), FEProblemBase::reinitMaterials(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsNeighbor(), and FEProblemBase::updateActiveObjects().

_displaced_mesh

MooseMesh* FEProblemBase::_displaced_mesh

protectedinherited

Definition at line 3449 of file FEProblemBase.h.

Referenced by FEProblemBase::addDisplacedProblem(), FEProblemBase::addGhostedBoundary(), FEProblemBase::checkDisplacementOrders(), FEProblemBase::ghostGhostedBoundaries(), FEProblemBase::init(), FEProblemBase::initXFEM(), FEProblemBase::meshChanged(), FEProblemBase::possiblyRebuildGeomSearchPatches(), FEProblemBase::prepare(), FEProblemBase::prepare(), FEProblemBase::prepareFace(), FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElem(), FEProblemBase::reinitElemFace(), FEProblemBase::reinitElemFaceRef(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitLowerDElem(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNeighborFaceRef(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::setCurrentLowerDElem(), and FEProblemBase::timestepSetup().

_displaced_problem

std::shared_ptr<DisplacedProblem> FEProblemBase::_displaced_problem

protectedinherited

Definition at line 3450 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarKernel(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::addCachedJacobian(), FEProblemBase::addCachedResidual(), FEProblemBase::addCachedResidualDirectly(), FEProblemBase::addConstraint(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addDisplacedProblem(), FEProblemBase::addFunction(), FEProblemBase::addFunctorMaterial(), FEProblemBase::addFVKernel(), FEProblemBase::addGhostedBoundary(), FEProblemBase::addIndicator(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addJacobian(), FEProblemBase::addJacobianBlockTags(), FEProblemBase::addJacobianLowerD(), FEProblemBase::addJacobianNeighbor(), FEProblemBase::addJacobianNeighborLowerD(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addObjectParamsHelper(), FEProblemBase::addResidual(), FEProblemBase::addResidualLower(), FEProblemBase::addResidualNeighbor(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), FEProblemBase::addVariable(), FEProblemBase::advanceState(), FEProblemBase::automaticScaling(), FEProblemBase::backupGeometricSearchState(), FEProblemBase::bumpAllQRuleOrder(), FEProblemBase::bumpVolumeQRuleOrder(), FEProblemBase::cacheJacobian(), FEProblemBase::cacheJacobianNeighbor(), FEProblemBase::cacheResidual(), FEProblemBase::cacheResidualNeighbor(), FEProblemBase::checkDisplacementOrders(), FEProblemBase::clearActiveElementalMooseVariables(), FEProblemBase::clearActiveFEVariableCoupleableMatrixTags(), FEProblemBase::clearActiveFEVariableCoupleableVectorTags(), FEProblemBase::clearActiveScalarVariableCoupleableMatrixTags(), FEProblemBase::clearActiveScalarVariableCoupleableVectorTags(), FEProblemBase::clearDiracInfo(), FEProblemBase::computeJacobianBlocks(), EigenProblem::computeJacobianBlocks(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::computeUserObjectsInternal(), FEProblemBase::computingNonlinearResid(), FEProblemBase::createMortarInterface(), FEProblemBase::createQRules(), FEProblemBase::customSetup(), FEProblemBase::execute(), FEProblemBase::getDiracElements(), FEProblemBase::getDisplacedProblem(), FEProblemBase::getDisplacedProblem(), FEProblemBase::getMortarUserObjects(), FEProblemBase::ghostGhostedBoundaries(), FEProblemBase::haveADObjects(), FEProblemBase::haveDisplaced(), FEProblemBase::init(), FEProblemBase::initXFEM(), FEProblemBase::jacobianSetup(), FEProblemBase::mesh(), FEProblemBase::mesh(), FEProblemBase::meshChanged(), FEProblemBase::outputStep(), FEProblemBase::possiblyRebuildGeomSearchPatches(), FEProblemBase::prepare(), FEProblemBase::prepare(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareAssemblyNeighbor(), FEProblemBase::prepareFace(), FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElem(), FEProblemBase::reinitElemFace(), FEProblemBase::reinitElemFaceRef(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitLowerDElem(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNeighborFaceRef(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::reinitOffDiagScalars(), FEProblemBase::reinitScalars(), FEProblemBase::resetState(), FEProblemBase::residualSetup(), FEProblemBase::restoreGeometricSearchState(), FEProblemBase::restoreSolutions(), FEProblemBase::setActiveElementalMooseVariables(), FEProblemBase::setActiveFEVariableCoupleableMatrixTags(), FEProblemBase::setActiveFEVariableCoupleableVectorTags(), FEProblemBase::setActiveScalarVariableCoupleableMatrixTags(), FEProblemBase::setActiveScalarVariableCoupleableVectorTags(), FEProblemBase::setAuxKernelParamsAndLog(), FEProblemBase::setCurrentBoundaryID(), FEProblemBase::setCurrentLowerDElem(), FEProblemBase::setCurrentlyComputingResidual(), FEProblemBase::setCurrentSubdomainID(), FEProblemBase::setNeighborSubdomainID(), FEProblemBase::setNeighborSubdomainID(), FEProblemBase::setResidual(), FEProblemBase::setResidualNeighbor(), FEProblemBase::setResidualObjectParamsAndLog(), FEProblemBase::solve(), EigenProblem::solve(), FEProblemBase::timestepSetup(), FEProblemBase::uniformRefine(), and FEProblemBase::updateGeomSearch().

_dt

Real& FEProblemBase::_dt

protectedinherited

Definition at line 3208 of file FEProblemBase.h.

Referenced by FEProblemBase::dt(), FEProblemBase::execMultiApps(), and FEProblemBase::FEProblemBase().

_dt_old

Real& FEProblemBase::_dt_old

protectedinherited

Definition at line 3209 of file FEProblemBase.h.

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

_enabled

const bool& MooseObject::_enabled

protectedinherited

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

Definition at line 71 of file MooseObject.h.

Referenced by MooseObject::enabled().

_error_on_jacobian_nonzero_reallocation

bool FEProblemBase::_error_on_jacobian_nonzero_reallocation

privateinherited

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

Definition at line 3705 of file FEProblemBase.h.

Referenced by FEProblemBase::errorOnJacobianNonzeroReallocation(), and FEProblemBase::setErrorOnJacobianNonzeroReallocation().

_evaluable_local_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_evaluable_local_elem_range

protectedinherited

Definition at line 3596 of file FEProblemBase.h.

Referenced by FEProblemBase::getEvaluableElementRange(), and FEProblemBase::meshChanged().

_exception_message

std::string FEProblemBase::_exception_message

protectedinherited

The error message to go with an exception.

Definition at line 3577 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), and FEProblemBase::setException().

_factory

Factory& SubProblem::_factory

protectedinherited

The Factory for building objects.

Definition at line 1048 of file SubProblem.h.

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

_fail_next_system_convergence_check

bool FEProblemBase::_fail_next_system_convergence_check

privateinherited

Definition at line 3719 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::getFailNextSystemConvergenceCheck(), FEProblemBase::resetFailNextSystemConvergenceCheck(), FEProblemBase::setFailNextSystemConvergenceCheck(), and FEProblemBase::solve().

_fe_matrix_tags

std::set<TagID> FEProblemBase::_fe_matrix_tags

protectedinherited

Definition at line 3192 of file FEProblemBase.h.

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

_fe_vector_tags

std::set<TagID> FEProblemBase::_fe_vector_tags

protectedinherited

Definition at line 3190 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), EigenProblem::computeResidualAB(), FEProblemBase::computeResidualAndJacobian(), and EigenProblem::computeResidualTag().

_force_restart

const bool FEProblemBase::_force_restart

privateinherited

Definition at line 3716 of file FEProblemBase.h.

_from_multi_app_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_from_multi_app_transfers

protectedinherited

Transfers executed just after MultiApps to transfer data from them.

Definition at line 3366 of file FEProblemBase.h.

Referenced by FEProblemBase::addTransfer(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::getMultiAppTransferWarehouse(), FEProblemBase::getTransfers(), FEProblemBase::getTransfers(), and FEProblemBase::updateActiveObjects().

_functions

MooseObjectWarehouse<Function> FEProblemBase::_functions

protectedinherited

functions

Definition at line 3296 of file FEProblemBase.h.

Referenced by FEProblemBase::addFunction(), MFEMProblem::addFunction(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::customSetup(), FEProblemBase::getFunction(), FEProblemBase::getFunctionWarehouse(), FEProblemBase::hasFunction(), DumpObjectsProblem::initialSetup(), and FEProblemBase::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

protectedinherited

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

Definition at line 3536 of file FEProblemBase.h.

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

_fv_face_integrity_check

const bool FEProblemBase::_fv_face_integrity_check

protectedinherited

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

Definition at line 3539 of file FEProblemBase.h.

_fv_ics

FVInitialConditionWarehouse FEProblemBase::_fv_ics

protectedinherited

Definition at line 3314 of file FEProblemBase.h.

Referenced by FEProblemBase::addFVInitialCondition(), and FEProblemBase::getFVInitialConditionWarehouse().

_geometric_search_data

GeometricSearchData FEProblemBase::_geometric_search_data

protectedinherited

Definition at line 3451 of file FEProblemBase.h.

Referenced by FEProblemBase::backupGeometricSearchState(), FEProblemBase::geomSearchData(), FEProblemBase::meshChanged(), FEProblemBase::possiblyRebuildGeomSearchPatches(), FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects(), FEProblemBase::restoreGeometricSearchState(), and FEProblemBase::updateGeomSearch().

_ghosted_elems

std::set<dof_id_type> SubProblem::_ghosted_elems

protectedinherited

Elements that should have Dofs ghosted to the local processor.

Definition at line 1094 of file SubProblem.h.

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

_grad_phi_zero

std::vector<VariablePhiGradient> FEProblemBase::_grad_phi_zero

inherited

Definition at line 2624 of file FEProblemBase.h.

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

_grad_zero

std::vector<VariableGradient> FEProblemBase::_grad_zero

inherited

Definition at line 2622 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::reinitDirac(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_has_active_elemental_moose_variables

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

protectedinherited

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

Definition at line 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

protectedinherited

Whether there are active material properties on each thread.

Definition at line 3509 of file FEProblemBase.h.

Referenced by FEProblemBase::clearActiveMaterialProperties(), FEProblemBase::FEProblemBase(), FEProblemBase::hasActiveMaterialProperties(), and FEProblemBase::setActiveMaterialProperties().

_has_constraints

bool FEProblemBase::_has_constraints

protectedinherited

Whether or not this system has any Constraints.

Definition at line 3468 of file FEProblemBase.h.

Referenced by FEProblemBase::addConstraint(), NonlinearSystemBase::computeJacobianInternal(), and NonlinearSystemBase::computeResidualInternal().

_has_dampers

bool FEProblemBase::_has_dampers

protectedinherited

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

Definition at line 3465 of file FEProblemBase.h.

Referenced by FEProblemBase::addDamper(), FEProblemBase::computeDamping(), FEProblemBase::computePostCheck(), and FEProblemBase::hasDampers().

_has_exception

bool FEProblemBase::_has_exception

protectedinherited

Whether or not an exception has occurred.

Definition at line 3562 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::hasException(), and FEProblemBase::setException().

_has_initialized_stateful

bool FEProblemBase::_has_initialized_stateful

protectedinherited

Whether nor not stateful materials have been initialized.

Definition at line 3480 of file FEProblemBase.h.

Referenced by FEProblemBase::meshChanged().

_has_internal_edge_residual_objects

bool FEProblemBase::_has_internal_edge_residual_objects

privateinherited

Whether the problem has dgkernels or interface kernels.

Definition at line 3728 of file FEProblemBase.h.

Referenced by FEProblemBase::addDGKernel(), FEProblemBase::addInterfaceKernel(), and FEProblemBase::hasNeighborCoupling().

_has_jacobian

bool FEProblemBase::_has_jacobian

protectedinherited

Indicates if the Jacobian was computed.

Definition at line 3486 of file FEProblemBase.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::hasJacobian(), FEProblemBase::meshChanged(), and FEProblemBase::prepare().

_has_kokkos_objects

bool FEProblemBase::_has_kokkos_objects = false

privateinherited

Whether we have any Kokkos objects.

Definition at line 3794 of file FEProblemBase.h.

Referenced by FEProblemBase::hasKokkosObjects(), FEProblemBase::init(), and FEProblemBase::initElementStatefulProps().

_has_kokkos_residual_objects

bool FEProblemBase::_has_kokkos_residual_objects = false

privateinherited

Whether we have any Kokkos residual objects.

Definition at line 3797 of file FEProblemBase.h.

Referenced by FEProblemBase::hasKokkosResidualObjects().

_has_mortar

bool FEProblemBase::_has_mortar

privateinherited

Whether the simulation requires mortar coupling.

Definition at line 3750 of file FEProblemBase.h.

Referenced by FEProblemBase::createMortarInterface(), and FEProblemBase::hasMortarCoupling().

_has_nonlocal_coupling

bool FEProblemBase::_has_nonlocal_coupling

protectedinherited

Indicates if nonlocal coupling is required/exists.

Definition at line 3503 of file FEProblemBase.h.

Referenced by FEProblemBase::addJacobian(), FEProblemBase::addJacobianBlockTags(), FEProblemBase::hasNonlocalCoupling(), FEProblemBase::prepare(), FEProblemBase::prepare(), FEProblemBase::prepareAssembly(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElemPhys(), and FEProblemBase::timestepSetup().

_has_time_integrator

bool FEProblemBase::_has_time_integrator

protectedinherited

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

Definition at line 3559 of file FEProblemBase.h.

Referenced by FEProblemBase::addTimeIntegrator(), and FEProblemBase::hasTimeIntegrator().

_have_ad_objects

bool SubProblem::_have_ad_objects

protectedinherited

AD flag indicating whether any AD objects have been added.

Definition at line 1115 of file SubProblem.h.

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

_have_fv

bool FEProblemBase::_have_fv = false

privateinherited

Whether we are performing some calculations with finite volume discretizations.

Definition at line 3780 of file FEProblemBase.h.

Referenced by FEProblemBase::haveFV(), and FEProblemBase::needFV().

_ics

InitialConditionWarehouse FEProblemBase::_ics

protectedinherited

Initial condition storage

Definition at line 3313 of file FEProblemBase.h.

Referenced by FEProblemBase::addInitialCondition(), and FEProblemBase::getInitialConditionWarehouse().

_identify_variable_groups_in_nl

const bool FEProblemBase::_identify_variable_groups_in_nl

privateinherited

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

Definition at line 3772 of file FEProblemBase.h.

Referenced by FEProblemBase::identifyVariableGroupsInNL().

_ignore_zeros_in_jacobian

bool FEProblemBase::_ignore_zeros_in_jacobian

privateinherited

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

Definition at line 3712 of file FEProblemBase.h.

Referenced by FEProblemBase::ignoreZerosInJacobian(), FEProblemBase::setIgnoreZerosInJacobian(), and FEProblemBase::setPreserveMatrixSparsityPattern().

_immediately_print_invalid_solution

const bool& FEProblemBase::_immediately_print_invalid_solution

privateinherited

Definition at line 3722 of file FEProblemBase.h.

Referenced by FEProblemBase::immediatelyPrintInvalidSolution().

_indicators

MooseObjectWarehouse<Indicator> FEProblemBase::_indicators

protectedinherited

Definition at line 3343 of file FEProblemBase.h.

Referenced by FEProblemBase::addIndicator(), FEProblemBase::computeIndicators(), FEProblemBase::customSetup(), FEProblemBase::getIndicatorWarehouse(), FEProblemBase::timestepSetup(), and FEProblemBase::updateActiveObjects().

_initialized

bool FEProblemBase::_initialized

protectedinherited

Definition at line 3179 of file FEProblemBase.h.

Referenced by FEProblemBase::init(), FEProblemBase::initialized(), and FEProblemBase::updateMortarMesh().

_input_file_saved

bool FEProblemBase::_input_file_saved

protectedinherited

whether input file has been written

Definition at line 3462 of file FEProblemBase.h.

_interface_kernel_integrity_check

const bool FEProblemBase::_interface_kernel_integrity_check

protectedinherited

Whether to check that interface kernel variables match the orientation of their boundaries.

Definition at line 3526 of file FEProblemBase.h.

_interface_mat_side_cache

std::vector<std::unordered_map<BoundaryID, bool> > FEProblemBase::_interface_mat_side_cache

protectedinherited

Cache for calculating materials on interface.

Definition at line 3384 of file FEProblemBase.h.

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

_interface_materials

MaterialWarehouse FEProblemBase::_interface_materials

protectedinherited

Definition at line 3332 of file FEProblemBase.h.

Referenced by FEProblemBase::addInterfaceMaterial(), FEProblemBase::getInterfaceMaterialsWarehouse(), FEProblemBase::needInterfaceMaterialOnSide(), and FEProblemBase::reinitMaterialsInterface().

_internal_side_indicators

MooseObjectWarehouse<InternalSideIndicatorBase> FEProblemBase::_internal_side_indicators

protectedinherited

Definition at line 3344 of file FEProblemBase.h.

Referenced by FEProblemBase::addIndicator(), FEProblemBase::computeIndicators(), FEProblemBase::customSetup(), FEProblemBase::getInternalSideIndicatorWarehouse(), FEProblemBase::timestepSetup(), and FEProblemBase::updateActiveObjects().

_is_petsc_options_inserted

bool FEProblemBase::_is_petsc_options_inserted

protectedinherited

If or not PETSc options have been added to database.

Definition at line 3592 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::petscOptionsInserted(), FEProblemBase::solve(), and FEProblemBase::solveLinearSystem().

_kernel_coverage_blocks

std::vector<SubdomainName> FEProblemBase::_kernel_coverage_blocks

protectedinherited

Definition at line 3515 of file FEProblemBase.h.

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

_kernel_coverage_check

CoverageCheckMode FEProblemBase::_kernel_coverage_check

protectedinherited

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

Definition at line 3514 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity(), FEProblemBase::FEProblemBase(), FEProblemBase::setKernelCoverageCheck(), and FEProblemBase::setKernelCoverageCheck().

_kokkos_assembly

Moose::Kokkos::Assembly FEProblemBase::_kokkos_assembly

protectedinherited

Definition at line 3287 of file FEProblemBase.h.

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

_kokkos_bnd_material_props

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::_kokkos_bnd_material_props

protectedinherited

Definition at line 3326 of file FEProblemBase.h.

Referenced by FEProblemBase::advanceState(), and FEProblemBase::getKokkosBndMaterialPropertyStorage().

_kokkos_fe_systems

Moose::Kokkos::Array<Moose::Kokkos::FESystem> FEProblemBase::_kokkos_fe_systems

protectedinherited

FESystem array - sparsely populated (only slots for systems needing a Kokkos::FESystem)

Definition at line 3276 of file FEProblemBase.h.

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

_kokkos_functions

MooseObjectWarehouse<Moose::FunctionBase> FEProblemBase::_kokkos_functions

protectedinherited

Definition at line 3299 of file FEProblemBase.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::customSetup(), FEProblemBase::getKokkosFunction(), and FEProblemBase::timestepSetup().

_kokkos_material_props

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::_kokkos_material_props

protectedinherited

Definition at line 3325 of file FEProblemBase.h.

Referenced by FEProblemBase::advanceState(), and FEProblemBase::getKokkosMaterialPropertyStorage().

_kokkos_materials

MaterialWarehouse FEProblemBase::_kokkos_materials

protectedinherited

Definition at line 3337 of file FEProblemBase.h.

Referenced by FEProblemBase::getKokkosMaterialsWarehouse(), and FEProblemBase::updateActiveObjects().

_kokkos_mesh_initialization_hooks

std::vector<std::function<void()> > FEProblemBase::_kokkos_mesh_initialization_hooks

privateinherited

Container holding hooks for functions that need to be called after Kokkos mesh initialization.

Definition at line 3800 of file FEProblemBase.h.

Referenced by FEProblemBase::addKokkosMeshInitializationHook().

_kokkos_neighbor_material_props

Moose::Kokkos::MaterialPropertyStorage& FEProblemBase::_kokkos_neighbor_material_props

protectedinherited

Definition at line 3327 of file FEProblemBase.h.

Referenced by FEProblemBase::advanceState(), and FEProblemBase::getKokkosNeighborMaterialPropertyStorage().

_kokkos_systems

Moose::Kokkos::Array<Moose::Kokkos::System> FEProblemBase::_kokkos_systems

protectedinherited

System array - sparsely populated (only slots for systems needing a Kokkos::System)

Definition at line 3274 of file FEProblemBase.h.

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

_line_search

std::shared_ptr<LineSearch> FEProblemBase::_line_search

protectedinherited

Definition at line 3594 of file FEProblemBase.h.

Referenced by FEProblem::addLineSearch(), FEProblemBase::customSetup(), FEProblemBase::getLineSearch(), FEProblemBase::lineSearch(), and FEProblemBase::timestepSetup().

_linear_convergence_names

std::optional<std::vector<ConvergenceName> > FEProblemBase::_linear_convergence_names

protectedinherited

Linear system(s) convergence name(s) (if any)

Definition at line 3184 of file FEProblemBase.h.

Referenced by FEProblemBase::getLinearConvergenceNames(), FEProblemBase::hasLinearConvergenceObjects(), and FEProblemBase::setLinearConvergenceNames().

_linear_matrix_tags

std::set<TagID> FEProblemBase::_linear_matrix_tags

protectedinherited

Temporary storage for filtered matrix tags for linear systems.

Definition at line 3198 of file FEProblemBase.h.

Referenced by FEProblemBase::computeLinearSystemSys().

_linear_sys_name_to_num

std::map<LinearSystemName, unsigned int> FEProblemBase::_linear_sys_name_to_num

protectedinherited

Map from linear system name to number.

Definition at line 3228 of file FEProblemBase.h.

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

_linear_sys_names

const std::vector<LinearSystemName> FEProblemBase::_linear_sys_names

protectedinherited

The linear system names.

Definition at line 3219 of file FEProblemBase.h.

Referenced by DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), FEProblem::FEProblem(), FEProblemBase::FEProblemBase(), and FEProblemBase::getLinearSystemNames().

_linear_systems

std::vector<std::shared_ptr<LinearSystem> > FEProblemBase::_linear_systems

protectedinherited

The vector of linear systems.

Definition at line 3225 of file FEProblemBase.h.

Referenced by FEProblemBase::computeResidualL2Norm(), FEProblemBase::currentLinearSysNum(), DumpObjectsProblem::DumpObjectsProblem(), FEProblem::FEProblem(), FEProblemBase::getLinearSystem(), FEProblemBase::getLinearSystem(), FEProblemBase::setCurrentLinearSystem(), FEProblemBase::systemBaseLinear(), and FEProblemBase::systemBaseLinear().

_linear_vector_tags

std::set<TagID> FEProblemBase::_linear_vector_tags

protectedinherited

Temporary storage for filtered vector tags for linear systems.

Definition at line 3195 of file FEProblemBase.h.

Referenced by FEProblemBase::computeLinearSystemSys().

_map_block_material_props

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

protectedinherited

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

Definition at line 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

protectedinherited

Definition at line 3348 of file FEProblemBase.h.

Referenced by FEProblemBase::addMarker(), FEProblemBase::computeMarkers(), FEProblemBase::customSetup(), FEProblemBase::getMarkerWarehouse(), FEProblemBase::timestepSetup(), and FEProblemBase::updateActiveObjects().

_material_coverage_blocks

std::vector<SubdomainName> FEProblemBase::_material_coverage_blocks

protectedinherited

Definition at line 3533 of file FEProblemBase.h.

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

_material_coverage_check

CoverageCheckMode FEProblemBase::_material_coverage_check

protectedinherited

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

Definition at line 3532 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity(), FEProblemBase::FEProblemBase(), FEProblemBase::setMaterialCoverageCheck(), and FEProblemBase::setMaterialCoverageCheck().

_material_dependency_check

const bool FEProblemBase::_material_dependency_check

protectedinherited

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

Definition at line 3542 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity().

_material_prop_registry

MaterialPropertyRegistry FEProblemBase::_material_prop_registry

protectedinherited

Definition at line 3319 of file FEProblemBase.h.

Referenced by FEProblemBase::checkDependMaterialsHelper(), and FEProblemBase::getMaterialPropertyRegistry().

_material_property_requested

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

protectedinherited

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

Definition at line 1063 of file SubProblem.h.

Referenced by SubProblem::isMatPropRequested(), and SubProblem::markMatPropRequested().

_material_props

MaterialPropertyStorage& FEProblemBase::_material_props

protectedinherited

Definition at line 3320 of file FEProblemBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), FEProblemBase::advanceState(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorage(), FEProblemBase::getMaterialPropertyStorageConsumers(), FEProblemBase::initElementStatefulProps(), FEProblemBase::initXFEM(), FEProblemBase::meshChanged(), FEProblemBase::reinitMaterials(), and FEProblemBase::swapBackMaterials().

_materials

MaterialWarehouse FEProblemBase::_materials

protectedinherited

Definition at line 3331 of file FEProblemBase.h.

Referenced by FEProblemBase::addFunctorMaterial(), FEProblemBase::addMaterial(), FEProblemBase::getFVMatsAndDependencies(), FEProblemBase::getRegularMaterialsWarehouse(), FEProblemBase::prepareMaterials(), FEProblemBase::reinitMaterials(), FEProblemBase::reinitMaterialsBoundary(), FEProblemBase::reinitMaterialsFace(), FEProblemBase::reinitMaterialsFaceOnBoundary(), FEProblemBase::reinitMaterialsNeighbor(), and FEProblemBase::updateActiveObjects().

_matrix_tag_id_to_tag_name

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

protectedinherited

Reverse map.

Definition at line 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

protectedinherited

Maximum number of quadrature points used in the problem.

Definition at line 3553 of file FEProblemBase.h.

Referenced by FEProblemBase::getMaxQps(), FEProblemBase::reinitDirac(), and FEProblemBase::updateMaxQps().

_max_scalar_order

libMesh::Order FEProblemBase::_max_scalar_order

protectedinherited

Maximum scalar variable order.

Definition at line 3556 of file FEProblemBase.h.

Referenced by FEProblemBase::addAuxScalarVariable(), and FEProblemBase::getMaxScalarOrder().

_mesh

MooseMesh& FEProblemBase::_mesh

protectedinherited

Definition at line 3131 of file FEProblemBase.h.

Referenced by FEProblemBase::adaptMesh(), FEProblemBase::addAnyRedistributers(), FEProblemBase::addAuxVariable(), FEProblemBase::addGhostedBoundary(), FEProblemBase::addGhostedElem(), FEProblemBase::addVariable(), FEProblemBase::checkCoordinateSystems(), FEProblemBase::checkDependMaterialsHelper(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::checkUserObjects(), DumpObjectsProblem::dumpVariableHelper(), FEProblemBase::duplicateVariableCheck(), FEProblemBase::getCurrentAlgebraicBndNodeRange(), FEProblemBase::getCurrentAlgebraicElementRange(), FEProblemBase::getCurrentAlgebraicNodeRange(), FEProblemBase::getDiracElements(), FEProblemBase::getEvaluableElementRange(), FEProblemBase::getNonlinearEvaluableElementRange(), FEProblemBase::ghostGhostedBoundaries(), FEProblemBase::init(), FEProblemBase::initialAdaptMesh(), FEProblemBase::initXFEM(), FEProblemBase::mesh(), MFEMProblem::mesh(), FEProblemBase::mesh(), FEProblemBase::meshChanged(), FEProblemBase::possiblyRebuildGeomSearchPatches(), FEProblemBase::prepareMaterials(), FEProblemBase::projectInitialConditionOnCustomRange(), FEProblemBase::projectSolution(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitElemPhys(), FEProblemBase::reinitNeighborPhys(), FEProblemBase::reinitNeighborPhys(), FEProblemBase::setAxisymmetricCoordAxis(), FEProblemBase::setCoordSystem(), FEProblemBase::timestepSetup(), and FEProblemBase::uniformRefine().

_mesh_divisions

MooseObjectWarehouse<MeshDivision> FEProblemBase::_mesh_divisions

protectedinherited

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

Definition at line 3293 of file FEProblemBase.h.

Referenced by FEProblemBase::addMeshDivision(), and FEProblemBase::getMeshDivision().

_metaname

const RestartableDataMapName Restartable::_metaname

privateinherited

Restartable metadata name.

Definition at line 247 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

_mfem_solver_definitions

std::map<std::string, MFEMSolverDefinition> MFEMProblem::_mfem_solver_definitions

protectedinherited

Solver definitions recorded by AddMFEMSolverAction before the dependency resolver constructs them.

Each key is the user-provided solver object name, which corresponds to a child block name under [Solvers]. Solver parameters of type MFEMSolverName refer to these same keys when declaring dependencies between solver objects.

Definition at line 471 of file MFEMProblem.h.

Referenced by MFEMProblem::addMFEMSolver(), and MFEMProblem::resolveMFEMSolvers().

_mortar_data

std::unique_ptr<MortarInterfaceWarehouse> FEProblemBase::_mortar_data

protectedinherited

Definition at line 3452 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::createMortarInterface(), FEProblemBase::getMortarInterface(), FEProblemBase::getMortarInterface(), FEProblemBase::getMortarInterfaces(), FEProblemBase::init(), FEProblemBase::meshChanged(), FEProblemBase::mortarData(), FEProblemBase::mortarData(), FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects(), and FEProblemBase::updateMortarMesh().

_multi_apps

ExecuteMooseObjectWarehouse<MultiApp> FEProblemBase::_multi_apps

protectedinherited

MultiApp Warehouse.

Definition at line 3354 of file FEProblemBase.h.

Referenced by FEProblemBase::addMultiApp(), FEProblemBase::backupMultiApps(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::finalizeMultiApps(), FEProblemBase::finishMultiAppStep(), FEProblemBase::getMultiApp(), FEProblemBase::getMultiAppWarehouse(), FEProblemBase::hasMultiApp(), FEProblemBase::hasMultiApps(), FEProblemBase::hasMultiApps(), FEProblemBase::incrementMultiAppTStep(), FEProblemBase::parentOutputPositionChanged(), FEProblemBase::partitionConcurrentMultiApps(), FEProblemBase::postExecute(), FEProblemBase::restoreMultiApps(), and FEProblemBase::updateActiveObjects().

_multiapp_fixed_point_convergence_name

std::optional<ConvergenceName> FEProblemBase::_multiapp_fixed_point_convergence_name

protectedinherited

MultiApp fixed point convergence name.

Definition at line 3186 of file FEProblemBase.h.

Referenced by FEProblemBase::getMultiAppFixedPointConvergenceName(), FEProblemBase::hasSetMultiAppFixedPointConvergenceName(), and FEProblemBase::setMultiAppFixedPointConvergenceName().

_name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

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

_need_to_add_default_multiapp_fixed_point_convergence

bool FEProblemBase::_need_to_add_default_multiapp_fixed_point_convergence

protectedinherited

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

Definition at line 3214 of file FEProblemBase.h.

Referenced by FEProblemBase::needToAddDefaultMultiAppFixedPointConvergence(), and FEProblemBase::setNeedToAddDefaultMultiAppFixedPointConvergence().

_need_to_add_default_nonlinear_convergence

bool FEProblemBase::_need_to_add_default_nonlinear_convergence

protectedinherited

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

Definition at line 3212 of file FEProblemBase.h.

Referenced by FEProblemBase::needToAddDefaultNonlinearConvergence(), and FEProblemBase::setNeedToAddDefaultNonlinearConvergence().

_need_to_add_default_steady_state_convergence

bool FEProblemBase::_need_to_add_default_steady_state_convergence

protectedinherited

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

Definition at line 3216 of file FEProblemBase.h.

Referenced by FEProblemBase::needToAddDefaultSteadyStateConvergence(), and FEProblemBase::setNeedToAddDefaultSteadyStateConvergence().

_needs_old_newton_iter

bool FEProblemBase::_needs_old_newton_iter

protectedinherited

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

Definition at line 3489 of file FEProblemBase.h.

_neighbor_material_props

MaterialPropertyStorage& FEProblemBase::_neighbor_material_props

protectedinherited

Definition at line 3322 of file FEProblemBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), FEProblemBase::advanceState(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::getMaterialData(), FEProblemBase::getMaterialPropertyStorageConsumers(), FEProblemBase::getNeighborMaterialPropertyStorage(), FEProblemBase::initElementStatefulProps(), FEProblemBase::meshChanged(), FEProblemBase::reinitMaterialsNeighbor(), and FEProblemBase::swapBackMaterialsNeighbor().

_nl

std::vector<std::shared_ptr<NonlinearSystemBase> > FEProblemBase::_nl

protectedinherited

The nonlinear systems.

Definition at line 3243 of file FEProblemBase.h.

Referenced by FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addDamper(), FEProblemBase::addDGKernel(), FEProblemBase::addDiracKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addKernel(), FEProblemBase::addNodalKernel(), FEProblemBase::addPredictor(), FEProblemBase::addScalarKernel(), FEProblemBase::addTimeIntegrator(), FEProblemBase::bumpAllQRuleOrder(), FEProblemBase::bumpVolumeQRuleOrder(), FEProblemBase::checkNonlocalCoupling(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::computeResidualL2Norm(), FEProblemBase::computingPreSMOResidual(), FEProblemBase::currentNlSysNum(), FEProblemBase::customSetup(), DumpObjectsProblem::DumpObjectsProblem(), ExternalProblem::ExternalProblem(), FEProblemBase::finalNonlinearResidual(), FEProblemBase::getNonlinearEvaluableElementRange(), FEProblemBase::getNonlinearSystem(), FEProblemBase::getNonlinearSystemBase(), FEProblemBase::getNonlinearSystemBase(), FEProblemBase::init(), FEProblemBase::initXFEM(), FEProblemBase::jacobianSetup(), FEProblemBase::meshChanged(), FEProblemBase::needBoundaryMaterialOnSide(), FEProblemBase::needInterfaceMaterialOnSide(), FEProblemBase::needInternalNeighborSideMaterial(), FEProblemBase::nLinearIterations(), FEProblemBase::nNonlinearIterations(), FEProblemBase::onTimestepBegin(), FEProblemBase::prepare(), FEProblemBase::prepareFace(), FEProblemBase::projectInitialConditionOnCustomRange(), FEProblemBase::projectSolution(), FEProblemBase::reinitDirac(), FEProblemBase::reinitNeighbor(), FEProblemBase::reinitNeighborPhys(), FEProblemBase::reinitNeighborPhys(), FEProblemBase::reinitNode(), FEProblemBase::reinitNodeFace(), FEProblemBase::reinitScalars(), FEProblemBase::residualSetup(), FEProblemBase::setCurrentNonlinearSystem(), FEProblemBase::setNeighborSubdomainID(), FEProblemBase::setNeighborSubdomainID(), FEProblemBase::setNonlinearConvergenceNames(), FEProblemBase::setNonlocalCouplingMatrix(), FEProblemBase::setResidual(), FEProblemBase::setResidualObjectParamsAndLog(), FEProblemBase::setupDampers(), FEProblemBase::subdomainSetup(), FEProblemBase::systemBaseNonlinear(), FEProblemBase::systemBaseNonlinear(), FEProblemBase::updateActiveObjects(), and FEProblemBase::updateMeshXFEM().

_nl_evaluable_local_elem_range

std::unique_ptr<libMesh::ConstElemRange> FEProblemBase::_nl_evaluable_local_elem_range

protectedinherited

Definition at line 3597 of file FEProblemBase.h.

Referenced by FEProblemBase::getNonlinearEvaluableElementRange(), and FEProblemBase::meshChanged().

_nl_sys_name_to_num

std::map<NonlinearSystemName, unsigned int> FEProblemBase::_nl_sys_name_to_num

protectedinherited

Map from nonlinear system name to number.

Definition at line 3246 of file FEProblemBase.h.

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

_nl_sys_names

const std::vector<NonlinearSystemName> FEProblemBase::_nl_sys_names

protectedinherited

The nonlinear system names.

Definition at line 3237 of file FEProblemBase.h.

Referenced by DumpObjectsProblem::DumpObjectsProblem(), EigenProblem::EigenProblem(), FEProblem::FEProblem(), FEProblemBase::FEProblemBase(), and FEProblemBase::getNonlinearSystemNames().

_nonlinear_convergence_names

std::optional<std::vector<ConvergenceName> > FEProblemBase::_nonlinear_convergence_names

protectedinherited

Nonlinear system(s) convergence name(s)

Definition at line 3182 of file FEProblemBase.h.

Referenced by FEProblemBase::getNonlinearConvergenceNames(), and FEProblemBase::setNonlinearConvergenceNames().

_nonlocal_cm

std::vector<libMesh::CouplingMatrix> FEProblemBase::_nonlocal_cm

privateinherited

nonlocal coupling matrix

Definition at line 3787 of file FEProblemBase.h.

Referenced by FEProblemBase::addJacobianBlockTags(), FEProblemBase::FEProblemBase(), FEProblemBase::nonlocalCouplingMatrix(), FEProblemBase::prepare(), and FEProblemBase::setNonlocalCouplingMatrix().

_nonlocal_integrated_bcs

MooseObjectWarehouse<IntegratedBCBase> FEProblemBase::_nonlocal_integrated_bcs

protectedinherited

nonlocal integrated_bcs

Definition at line 3309 of file FEProblemBase.h.

Referenced by FEProblemBase::checkNonlocalCoupling(), FEProblemBase::setNonlocalCouplingMatrix(), and FEProblemBase::timestepSetup().

_nonlocal_kernels

MooseObjectWarehouse<KernelBase> FEProblemBase::_nonlocal_kernels

protectedinherited

nonlocal kernels

Definition at line 3306 of file FEProblemBase.h.

Referenced by FEProblemBase::checkNonlocalCoupling(), FEProblemBase::setNonlocalCouplingMatrix(), and FEProblemBase::timestepSetup().

_not_zeroed_tagged_vectors

std::unordered_set<TagID> SubProblem::_not_zeroed_tagged_vectors

protectedinherited

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

Definition at line 1118 of file SubProblem.h.

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

_notify_when_mesh_changes

std::vector<MeshChangedInterface *> FEProblemBase::_notify_when_mesh_changes

protectedinherited

Objects to be notified when the mesh changes.

Definition at line 3387 of file FEProblemBase.h.

Referenced by FEProblemBase::meshChanged(), and FEProblemBase::notifyWhenMeshChanges().

_notify_when_mesh_displaces

std::vector<MeshDisplacedInterface *> FEProblemBase::_notify_when_mesh_displaces

protectedinherited

Objects to be notified when the mesh displaces.

Definition at line 3390 of file FEProblemBase.h.

Referenced by FEProblemBase::meshDisplaced(), and FEProblemBase::notifyWhenMeshDisplaces().

_num_concurrent_multiapps

const unsigned int FEProblemBase::_num_concurrent_multiapps

protectedinherited

Number of concurrent applications being solved at the same time.

Definition at line 3372 of file FEProblemBase.h.

Referenced by FEProblemBase::execMultiApps(), FEProblemBase::numConcurrentMultiApps(), and FEProblemBase::partitionConcurrentMultiApps().

_num_grid_steps

unsigned int FEProblemBase::_num_grid_steps

privateinherited

Number of steps in a grid sequence.

Definition at line 3753 of file FEProblemBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), FEProblemBase::checkProblemIntegrity(), FEProblemBase::numGridSteps(), and FEProblemBase::timestepSetup().

_num_linear_sys

const std::size_t FEProblemBase::_num_linear_sys

protectedinherited

The number of linear systems.

Definition at line 3222 of file FEProblemBase.h.

Referenced by FEProblem::FEProblem(), FEProblemBase::FEProblemBase(), FEProblemBase::numLinearSystems(), and FEProblemBase::numSolverSystems().

_num_nl_sys

const std::size_t FEProblemBase::_num_nl_sys

protectedinherited

The number of nonlinear systems.

Definition at line 3240 of file FEProblemBase.h.

Referenced by ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), FEProblemBase::FEProblemBase(), FEProblemBase::isSolverSystemNonlinear(), FEProblemBase::numNonlinearSystems(), FEProblemBase::numSolverSystems(), and FEProblemBase::prepare().

_num_type

NumericType MFEMProblem::_num_type

protectedinherited

The numeric representation currently active for this problem.

Definition at line 463 of file MFEMProblem.h.

Referenced by MFEMProblem::getNumericType(), MFEMEigenproblem(), and MFEMProblem::validateVariableNumericType().

_parallel_barrier_messaging

bool FEProblemBase::_parallel_barrier_messaging

protectedinherited

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

Definition at line 3565 of file FEProblemBase.h.

Referenced by FEProblemBase::backupMultiApps(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::finishMultiAppStep(), FEProblemBase::restoreMultiApps(), and FEProblemBase::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(), 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

protectedinherited

Definition at line 3588 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::petscOptionsDatabase(), FEProblemBase::solve(), EigenProblem::solve(), FEProblemBase::solveLinearSystem(), and FEProblemBase::~FEProblemBase().

_petsc_options

Moose::PetscSupport::PetscOptions FEProblemBase::_petsc_options

protectedinherited

PETSc option storage.

Definition at line 3586 of file FEProblemBase.h.

Referenced by FEProblemBase::getPetscOptions(), FEProblemBase::solve(), and FEProblemBase::solveLinearSystem().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

_phi_zero

std::vector<VariablePhiValue> FEProblemBase::_phi_zero

inherited

Definition at line 2620 of file FEProblemBase.h.

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

_point_zero

std::vector<Point> FEProblemBase::_point_zero

inherited

Definition at line 2628 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase().

_prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_preserve_matrix_sparsity_pattern

bool FEProblemBase::_preserve_matrix_sparsity_pattern

privateinherited

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

Definition at line 3714 of file FEProblemBase.h.

Referenced by FEProblemBase::preserveMatrixSparsityPattern(), and FEProblemBase::setPreserveMatrixSparsityPattern().

_previous_multiapp_fp_aux_solution_required

bool FEProblemBase::_previous_multiapp_fp_aux_solution_required

protectedinherited

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

Definition at line 3496 of file FEProblemBase.h.

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

_previous_multiapp_fp_nl_solution_required

std::vector<bool> FEProblemBase::_previous_multiapp_fp_nl_solution_required

protectedinherited

Indicates we need to save the previous multiapp fixed-point iteration solver variable values.

Definition at line 3494 of file FEProblemBase.h.

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

_previous_multisystem_fp_aux_solution_required

bool FEProblemBase::_previous_multisystem_fp_aux_solution_required

protectedinherited

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

Definition at line 3500 of file FEProblemBase.h.

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

_previous_multisystem_fp_nl_solution_required

std::vector<bool> FEProblemBase::_previous_multisystem_fp_nl_solution_required

protectedinherited

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

Definition at line 3498 of file FEProblemBase.h.

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

_previous_nl_solution_required

bool FEProblemBase::_previous_nl_solution_required

protectedinherited

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

Definition at line 3492 of file FEProblemBase.h.

Referenced by FEProblemBase::createTagSolutions().

_print_execution_on

ExecFlagEnum FEProblemBase::_print_execution_on

privateinherited

When to print the execution of loops.

Definition at line 3769 of file FEProblemBase.h.

Referenced by FEProblemBase::setExecutionPrinting(), and FEProblemBase::shouldPrintExecution().

_problem_composer

std::shared_ptr<MFEMProblemComposer> MFEMProblem::_problem_composer

protectedinherited

The problem operator builders for this mfem problem.

Definition at line 479 of file MFEMProblem.h.

Referenced by MFEMProblem::addProblemComposer().

_problem_data

MFEMProblemData MFEMProblem::_problem_data

protectedinherited

Aggregated MFEM-side state for meshes, spaces, variables, coefficients, and solvers.

Definition at line 458 of file MFEMProblem.h.

Referenced by MFEMProblem::addBoundaryCondition(), MFEMProblem::addKernel(), MFEMProblem::getCoefficients(), MFEMProblem::getComplexGridFunction(), MFEMProblem::getGridFunction(), MFEMProblem::getMFEMVariableMesh(), MFEMProblem::getProblemData(), MFEMProblem::getProblemData(), MFEMProblem::hRefine(), MFEMProblem::pRefine(), MFEMProblem::setEquationSystems(), MFEMProblem::updateFESpaces(), and MFEMProblem::updateGridFunctions().

_problem_operators

std::vector<std::shared_ptr<Moose::MFEM::ProblemOperatorBase> > MFEMProblem::_problem_operators

protectedinherited

Vector of MFEM problem operators executed in this problem.

Definition at line 483 of file MFEMProblem.h.

Referenced by MFEMProblem::getProblemOperators(), and MFEMProblem::setProblemOperators().

_random_data_objects

std::map<std::string, std::unique_ptr<RandomData> > FEProblemBase::_random_data_objects

protectedinherited

A map of objects that consume random numbers.

Definition at line 3375 of file FEProblemBase.h.

Referenced by FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::registerRandomInterface(), and FEProblemBase::timestepSetup().

_real_zero

std::vector<Real> FEProblemBase::_real_zero

inherited

Convenience zeros.

Definition at line 2617 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase().

_regard_general_exceptions_as_errors

const bool FEProblemBase::_regard_general_exceptions_as_errors

privateinherited

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

Referenced by FEProblemBase::translateCaughtException().

_reinit_displaced_elem

bool FEProblemBase::_reinit_displaced_elem

protectedinherited

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

Definition at line 3455 of file FEProblemBase.h.

Referenced by FEProblemBase::addDiracKernel(), FEProblemBase::addFVKernel(), FEProblemBase::addHDGKernel(), FEProblemBase::addIndicator(), FEProblemBase::addKernel(), FEProblemBase::addMarker(), FEProblemBase::addMaterialHelper(), FEProblemBase::addMultiApp(), FEProblemBase::addNodalKernel(), FEProblemBase::addTransfer(), FEProblemBase::addUserObject(), FEProblemBase::prepare(), FEProblemBase::prepare(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareFace(), FEProblemBase::reinitDirac(), FEProblemBase::reinitElem(), FEProblemBase::reinitNode(), FEProblemBase::reinitScalars(), FEProblemBase::setAuxKernelParamsAndLog(), FEProblemBase::setCurrentSubdomainID(), FEProblemBase::setNeighborSubdomainID(), and FEProblemBase::setNeighborSubdomainID().

_reinit_displaced_face

bool FEProblemBase::_reinit_displaced_face

protectedinherited

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

Definition at line 3457 of file FEProblemBase.h.

Referenced by FEProblemBase::addBoundaryCondition(), FEProblemBase::addConstraint(), FEProblemBase::addMaterialHelper(), FEProblemBase::addUserObject(), FEProblemBase::prepare(), FEProblemBase::prepare(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareAssemblyNeighbor(), FEProblemBase::prepareFace(), FEProblemBase::reinitElemFace(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitNodeFace(), FEProblemBase::setAuxKernelParamsAndLog(), FEProblemBase::setCurrentSubdomainID(), FEProblemBase::setNeighborSubdomainID(), and FEProblemBase::setNeighborSubdomainID().

_reinit_displaced_neighbor

bool FEProblemBase::_reinit_displaced_neighbor

protectedinherited

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

Definition at line 3459 of file FEProblemBase.h.

Referenced by FEProblemBase::addDGKernel(), FEProblemBase::addInterfaceKernel(), FEProblemBase::addMaterialHelper(), FEProblemBase::addUserObject(), FEProblemBase::prepare(), FEProblemBase::prepareAssembly(), FEProblemBase::prepareAssemblyNeighbor(), FEProblemBase::reinitElemNeighborAndLowerD(), FEProblemBase::reinitNeighbor(), FEProblemBase::setCurrentSubdomainID(), FEProblemBase::setNeighborSubdomainID(), and FEProblemBase::setNeighborSubdomainID().

_reporter_data

ReporterData FEProblemBase::_reporter_data

protectedinherited

Definition at line 3351 of file FEProblemBase.h.

Referenced by FEProblemBase::advanceState(), FEProblemBase::checkDuplicatePostprocessorVariableNames(), MFEMProblem::executeMFEMObjects(), FEProblemBase::getPostprocessorValueByName(), FEProblemBase::getReporterData(), FEProblemBase::getReporterData(), FEProblemBase::getVectorPostprocessorValueByName(), FEProblemBase::hasPostprocessorValueByName(), FEProblemBase::joinAndFinalize(), FEProblemBase::restoreSolutions(), FEProblemBase::setPostprocessorValueByName(), and FEProblemBase::setVectorPostprocessorValueByName().

_req

Restartable::ManagedValue<RestartableEquationSystems> FEProblemBase::_req

privateinherited

The EquationSystems object, wrapped for restart.

Definition at line 3135 of file FEProblemBase.h.

Referenced by FEProblemBase::es(), and FEProblemBase::getRestartableEquationSystems().

_requires_nonlocal_coupling

bool FEProblemBase::_requires_nonlocal_coupling

privateinherited

nonlocal coupling requirement flag

Definition at line 3790 of file FEProblemBase.h.

Referenced by FEProblemBase::checkNonlocalCoupling(), FEProblemBase::checkNonlocalCouplingRequirement(), and FEProblemBase::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

privateinherited

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

Referenced by FEProblemBase::computeJacobianTags(), and FEProblemBase::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 FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::resetState(), and SubProblem::safeAccessTaggedMatrices().

_safe_access_tagged_vectors

bool SubProblem::_safe_access_tagged_vectors

protectedinherited

Is it safe to retrieve data from tagged vectors.

Definition at line 1112 of file SubProblem.h.

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

_scalar_ics

ScalarInitialConditionWarehouse FEProblemBase::_scalar_ics

protectedinherited

Definition at line 3315 of file FEProblemBase.h.

Referenced by FEProblemBase::addInitialCondition(), FEProblemBase::projectInitialConditionOnCustomRange(), and FEProblemBase::projectSolution().

_scalar_zero

std::vector<VariableValue> FEProblemBase::_scalar_zero

inherited

Definition at line 2618 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::reinitDirac(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_second_phi_zero

std::vector<VariablePhiSecond> FEProblemBase::_second_phi_zero

inherited

Definition at line 2627 of file FEProblemBase.h.

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

_second_zero

std::vector<VariableSecond> FEProblemBase::_second_zero

inherited

Definition at line 2625 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::reinitDirac(), FEProblemBase::updateMaxQps(), and FEProblemBase::~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

privateinherited

Definition at line 3721 of file FEProblemBase.h.

Referenced by FEProblemBase::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

protectedinherited

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

Definition at line 3529 of file FEProblemBase.h.

Referenced by FEProblemBase::sideUOInterfaceMatPropIntegrityCheck().

_skip_exception_check

bool FEProblemBase::_skip_exception_check

protectedinherited

If or not skip 'exception and stop solve'.

Definition at line 3474 of file FEProblemBase.h.

Referenced by FEProblemBase::checkExceptionAndStopSolve(), FEProblemBase::initialSetup(), and FEProblemBase::skipExceptionCheck().

_skip_nl_system_check

const bool FEProblemBase::_skip_nl_system_check

privateinherited

Definition at line 3718 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity(), and FEProblemBase::init().

_snesmf_reuse_base

bool FEProblemBase::_snesmf_reuse_base

protectedinherited

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

Definition at line 3471 of file FEProblemBase.h.

Referenced by FEProblemBase::setSNESMFReuseBase(), and FEProblemBase::useSNESMFReuseBase().

_snesmf_reuse_base_set_by_user

bool FEProblemBase::_snesmf_reuse_base_set_by_user

protectedinherited

If or not _snesmf_reuse_base is set by user.

Definition at line 3477 of file FEProblemBase.h.

Referenced by FEProblemBase::isSNESMFReuseBaseSetbyUser(), and FEProblemBase::setSNESMFReuseBase().

_solution_state_data

Moose::MFEM::SolutionState& MFEMProblem::_solution_state_data

protectedinherited

Restartable MFEM solution state associated with this problem.

Definition at line 474 of file MFEMProblem.h.

_solve

const bool& FEProblemBase::_solve

protectedinherited

Whether or not to actually solve the nonlinear system.

Definition at line 3201 of file FEProblemBase.h.

Referenced by FEProblemBase::checkProblemIntegrity(), FEProblemBase::FEProblemBase(), FEProblemBase::init(), FEProblemBase::shouldSolve(), FEProblemBase::solve(), EigenProblem::solve(), FEProblemBase::solveLinearSystem(), EigenProblem::solverSystemConverged(), and FEProblemBase::solverSystemConverged().

_solver_params

std::vector<SolverParams> FEProblemBase::_solver_params

protectedinherited

Definition at line 3511 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::solve(), FEProblemBase::solveLinearSystem(), and FEProblemBase::solverParams().

_solver_sys_name_to_num

std::map<SolverSystemName, unsigned int> FEProblemBase::_solver_sys_name_to_num

protectedinherited

Map connecting solver system names with their respective systems.

Definition at line 3261 of file FEProblemBase.h.

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

_solver_sys_names

std::vector<SolverSystemName> FEProblemBase::_solver_sys_names

protectedinherited

The union of nonlinear and linear system names.

Definition at line 3264 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::getSolverSystemNames(), FEProblemBase::getSystemBase(), Moose::PetscSupport::setSinglePetscOption(), and FEProblemBase::solverSysNum().

_solver_systems

std::vector<std::shared_ptr<SolverSystem> > FEProblemBase::_solver_systems

protectedinherited

Combined container to base pointer of every solver system.

Definition at line 3255 of file FEProblemBase.h.

Referenced by FEProblemBase::addObjectParamsHelper(), FEProblemBase::addTimeIntegrator(), FEProblemBase::addVariable(), FEProblemBase::advanceState(), FEProblemBase::computeSystems(), FEProblemBase::copySolutionsBackwards(), FEProblemBase::createQRules(), FEProblemBase::createTagMatrices(), FEProblemBase::createTagSolutions(), FEProblemBase::createTagVectors(), FEProblemBase::determineSolverSystem(), DumpObjectsProblem::DumpObjectsProblem(), FEProblemBase::duplicateVariableCheck(), EigenProblem::EigenProblem(), ExternalProblem::ExternalProblem(), FEProblem::FEProblem(), FEProblemBase::getActualFieldVariable(), FEProblemBase::getArrayVariable(), FEProblemBase::getScalarVariable(), FEProblemBase::getSolverSystem(), FEProblemBase::getSolverSystem(), FEProblemBase::getStandardVariable(), FEProblemBase::getSystem(), FEProblemBase::getSystemBase(), FEProblemBase::getSystemBase(), FEProblemBase::getVariable(), FEProblemBase::getVariableNames(), FEProblemBase::getVectorVariable(), FEProblemBase::hasScalarVariable(), FEProblemBase::hasSolutionState(), FEProblemBase::hasSolverVariable(), FEProblemBase::hasVariable(), FEProblem::init(), FEProblemBase::init(), FEProblemBase::meshChanged(), FEProblemBase::needSolutionState(), FEProblemBase::outputStep(), FEProblemBase::prepare(), FEProblemBase::projectSolution(), FEProblemBase::reinitElem(), FEProblemBase::reinitElemFace(), FEProblemBase::reinitElemPhys(), FEProblemBase::restoreOldSolutions(), FEProblemBase::restoreSolutions(), FEProblemBase::saveOldSolutions(), FEProblemBase::setAuxKernelParamsAndLog(), FEProblemBase::setCurrentSubdomainID(), Moose::PetscSupport::setSinglePetscOption(), FEProblemBase::setVariableAllDoFMap(), FEProblemBase::skipNextForwardSolutionCopyToOld(), FEProblemBase::solverSystemConverged(), FEProblemBase::systemBaseSolver(), FEProblemBase::systemBaseSolver(), FEProblemBase::systemNumForVariable(), and FEProblemBase::timestepSetup().

_solver_var_to_sys_num

std::map<SolverVariableName, unsigned int> FEProblemBase::_solver_var_to_sys_num

protectedinherited

Map connecting variable names with their respective solver systems.

Definition at line 3258 of file FEProblemBase.h.

Referenced by FEProblemBase::addVariable(), and FEProblemBase::determineSolverSystem().

_started_initial_setup

bool FEProblemBase::_started_initial_setup

privateinherited

At or beyond initialSteup stage.

Definition at line 3725 of file FEProblemBase.h.

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

_steady_state_convergence_name

std::optional<ConvergenceName> FEProblemBase::_steady_state_convergence_name

protectedinherited

Steady-state detection convergence name.

Definition at line 3188 of file FEProblemBase.h.

Referenced by FEProblemBase::getSteadyStateConvergenceName(), FEProblemBase::hasSetSteadyStateConvergenceName(), and FEProblemBase::setSteadyStateConvergenceName().

_subspace_dim

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

protectedinherited

Dimension of the subspace spanned by the vectors with a given prefix.

Definition at line 3280 of file FEProblemBase.h.

Referenced by FEProblemBase::initNullSpaceVectors(), and FEProblemBase::subspaceDim().

_t_step

int& FEProblemBase::_t_step

protectedinherited

Definition at line 3207 of file FEProblemBase.h.

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

_termination_requested

bool Problem::_termination_requested

protectedinherited

True if termination of the solve has been requested.

Definition at line 58 of file Problem.h.

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

_time

Real& FEProblemBase::_time

protectedinherited

Definition at line 3204 of file FEProblemBase.h.

Referenced by FEProblemBase::execMultiApps(), FEProblemBase::FEProblemBase(), FEProblemBase::incrementMultiAppTStep(), FEProblemBase::time(), and FEProblemBase::updateMeshXFEM().

_time_old

Real& FEProblemBase::_time_old

protectedinherited

Definition at line 3205 of file FEProblemBase.h.

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

_time_older

Real& FEProblemBase::_time_older

protectedinherited

Definition at line 3206 of file FEProblemBase.h.

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

_to_multi_app_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_to_multi_app_transfers

protectedinherited

Transfers executed just before MultiApps to transfer data to them.

Definition at line 3363 of file FEProblemBase.h.

Referenced by FEProblemBase::addTransfer(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::getMultiAppTransferWarehouse(), FEProblemBase::getTransfers(), FEProblemBase::getTransfers(), and FEProblemBase::updateActiveObjects().

_transfers

ExecuteMooseObjectWarehouse<Transfer> FEProblemBase::_transfers

protectedinherited

Normal Transfers.

Definition at line 3360 of file FEProblemBase.h.

Referenced by FEProblemBase::addTransfer(), and FEProblemBase::updateActiveObjects().

_transient

bool FEProblemBase::_transient

protectedinherited

Definition at line 3203 of file FEProblemBase.h.

Referenced by FEProblemBase::isTransient(), and FEProblemBase::transient().

_transient_multi_apps

ExecuteMooseObjectWarehouse<TransientMultiApp> FEProblemBase::_transient_multi_apps

protectedinherited

Storage for TransientMultiApps (only needed for calling 'computeDT')

Definition at line 3357 of file FEProblemBase.h.

Referenced by FEProblemBase::addMultiApp(), FEProblemBase::computeMultiAppsDT(), and FEProblemBase::updateActiveObjects().

_trust_user_coupling_matrix

bool FEProblemBase::_trust_user_coupling_matrix = false

privateinherited

Whether to trust the user coupling matrix no matter what.

See https://github.com/idaholab/moose/issues/16395 for detailed background

Definition at line 3757 of file FEProblemBase.h.

Referenced by FEProblemBase::setCoupling(), and FEProblemBase::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(), FEProblemBase::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

privateinherited

Whether old solution time derivative needs to be stored.

Definition at line 3737 of file FEProblemBase.h.

Referenced by FEProblemBase::setUDotOldRequested(), and FEProblemBase::uDotOldRequested().

_u_dot_requested

bool FEProblemBase::_u_dot_requested

privateinherited

Whether solution time derivative needs to be stored.

Definition at line 3731 of file FEProblemBase.h.

Referenced by FEProblemBase::setUDotRequested(), FEProblemBase::uDotOldRequested(), and FEProblemBase::uDotRequested().

_u_dotdot_old_requested

bool FEProblemBase::_u_dotdot_old_requested

privateinherited

Whether old solution second time derivative needs to be stored.

Definition at line 3740 of file FEProblemBase.h.

Referenced by FEProblemBase::setUDotDotOldRequested(), and FEProblemBase::uDotDotOldRequested().

_u_dotdot_requested

bool FEProblemBase::_u_dotdot_requested

privateinherited

Whether solution second time derivative needs to be stored.

Definition at line 3734 of file FEProblemBase.h.

Referenced by FEProblemBase::setUDotDotRequested(), FEProblemBase::uDotDotOldRequested(), and FEProblemBase::uDotDotRequested().

_uo_aux_state_check

const bool FEProblemBase::_uo_aux_state_check

protectedinherited

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

Definition at line 3545 of file FEProblemBase.h.

Referenced by FEProblemBase::execute(), and FEProblemBase::hasUOAuxStateCheck().

_uo_jacobian_moose_vars

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

protectedinherited

Definition at line 3506 of file FEProblemBase.h.

Referenced by FEProblemBase::checkUserObjectJacobianRequirement(), FEProblemBase::FEProblemBase(), FEProblemBase::getUserObjectJacobianVariables(), and FEProblemBase::meshChanged().

_use_hash_table_matrix_assembly

const bool FEProblemBase::_use_hash_table_matrix_assembly

protectedinherited

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

This can be a good option if the sparsity pattern changes throughout the course of the simulation

Definition at line 3618 of file FEProblemBase.h.

Referenced by EigenProblem::EigenProblem(), FEProblem::FEProblem(), and FEProblemBase::useHashTableMatrixAssembly().

_using_ad_mat_props

bool FEProblemBase::_using_ad_mat_props

protectedinherited

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

Definition at line 3606 of file FEProblemBase.h.

_using_default_nl

const bool FEProblemBase::_using_default_nl

protectedinherited

Boolean to check if we have the default nonlinear system.

Definition at line 3234 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(), FEProblemBase::setNonlocalCouplingMatrix(), and FEProblemBase::setVariableAllDoFMap().

_vector_curl_zero

std::vector<VectorVariableCurl> FEProblemBase::_vector_curl_zero

inherited

Definition at line 2630 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::reinitDirac(), FEProblemBase::updateMaxQps(), and FEProblemBase::~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

inherited

Definition at line 2629 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::reinitDirac(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_verbose_multiapps

bool FEProblemBase::_verbose_multiapps

protectedinherited

Whether or not to be verbose with multiapps.

Definition at line 3571 of file FEProblemBase.h.

Referenced by FEProblemBase::backupMultiApps(), FEProblemBase::execMultiApps(), FEProblemBase::execMultiAppTransfers(), FEProblemBase::finishMultiAppStep(), FEProblemBase::restoreMultiApps(), FEProblemBase::setVerboseProblem(), and FEProblemBase::verboseMultiApps().

_verbose_restore

bool FEProblemBase::_verbose_restore

protectedinherited

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

Definition at line 3574 of file FEProblemBase.h.

Referenced by FEProblemBase::restoreSolutions(), and FEProblemBase::setVerboseProblem().

_verbose_setup

MooseEnum FEProblemBase::_verbose_setup

protectedinherited

Whether or not to be verbose during setup.

Definition at line 3568 of file FEProblemBase.h.

Referenced by FEProblemBase::logAdd(), and FEProblemBase::setVerboseProblem().

_xfem

std::shared_ptr<XFEMInterface> FEProblemBase::_xfem

protectedinherited

Pointer to XFEM controller.

Definition at line 3446 of file FEProblemBase.h.

Referenced by FEProblemBase::getXFEM(), FEProblemBase::haveXFEM(), FEProblemBase::initXFEM(), and FEProblemBase::updateMeshXFEM().

_zero

std::vector<VariableValue> FEProblemBase::_zero

inherited

Definition at line 2619 of file FEProblemBase.h.

Referenced by FEProblemBase::FEProblemBase(), FEProblemBase::reinitDirac(), FEProblemBase::updateMaxQps(), and FEProblemBase::~FEProblemBase().

_zero_block_material_props

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

protectedinherited

Set of properties returned as zero properties.

Definition at line 1059 of file SubProblem.h.

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

_zero_boundary_material_props

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

protectedinherited

Definition at line 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 FEProblemBase::addAnyRedistributers(), MeshGenerator::addMeshSubgenerator(), InputParameters::callMooseError(), ActionFactory::create(), ActionFactory::getValidParams(), Factory::getValidParams(), AutomaticMortarGeneration::initOutput(), SetupMeshAction::modifyParamsForUseSplit(), and MortarNodalGeometryOutput::validParams().

kokkos_object_param

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

staticinherited

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

Definition at line 64 of file MooseBase.h.

Referenced by InputParameters::isKokkosObject().

moose_base_param

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

staticinherited

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

Definition at line 61 of file MooseBase.h.

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

name_param

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

staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

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

type_param

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

staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

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

unique_name_param

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

staticinherited

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

Definition at line 57 of file MooseBase.h.

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

usingCombinedWarningSolutionWarnings

MooseObject::usingCombinedWarningSolutionWarnings

inherited

Definition at line 67 of file MooseObject.h.

---

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

• include/mfem/problem/MFEMEigenproblem.h
• src/mfem/problem/MFEMEigenproblem.C