#include <DisplacedProblem.h>

Inheritance diagram for DisplacedProblem:

Classes
class	UpdateDisplacedMeshThread

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

Public Member Functions
	DisplacedProblem (DisplacedProblem &&)=delete

DisplacedProblem &	operator= (DisplacedProblem &&)=delete

	DisplacedProblem (const InputParameters &parameters)

	~DisplacedProblem ()

virtual EquationSystems &	es () override

virtual MooseMesh &	mesh () override

virtual const MooseMesh &	mesh () const override

const MooseMesh &	mesh (bool libmesh_dbg_var(use_displaced)) const override

MooseMesh &	refMesh ()

DisplacedSystem &	solverSys (const unsigned int sys_num)

DisplacedSystem &	auxSys ()

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 &	systemBaseLinear (const unsigned int sys_num) const override
	Return the linear system object as a base class reference given the system number.

virtual SystemBase &	systemBaseLinear (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

const std::vector< std::string > &	getDisplacementVarNames () const

virtual void	createQRules (QuadratureType type, Order order, Order volume_order, Order face_order, SubdomainID block, bool allow_negative_qweights=true)

void	bumpVolumeQRuleOrder (Order order, SubdomainID block)

void	bumpAllQRuleOrder (Order order, SubdomainID block)

virtual void	init () override

virtual bool	solverSystemConverged (const unsigned int solver_sys_num) override

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

virtual unsigned int	linearSysNum (const LinearSystemName &sys_name) const override

virtual unsigned int	solverSysNum (const SolverSystemName &sys_name) const override

void	addTimeIntegrator ()
	Get the time integrators from the problem.

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	syncAuxSolution (const NumericVector< Number > &aux_soln)
	Copy the provided solution into the displaced auxiliary system.

void	syncSolutions ()
	Copy the solutions on the undisplaced systems to the displaced systems.

void	syncSolutions (const std::map< unsigned int, const NumericVector< Number > * > &nl_solns, const NumericVector< Number > &aux_soln)
	Synchronize the solutions on the displaced systems to the given solutions.

virtual void	updateMesh (bool mesh_changing=false)
	Copy the solutions on the undisplaced systems to the displaced systems and reinitialize the geometry search data and Dirac kernel information due to mesh displacement.

virtual void	updateMesh (const std::map< unsigned int, const NumericVector< Number > * > &nl_soln, const NumericVector< Number > &aux_soln)
	Synchronize the solutions on the displaced systems to the given solutions and reinitialize the geometry search data and Dirac kernel information due to mesh displacement.

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

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

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

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

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

virtual bool	vectorTagExists (const TagName &tag_name) const override
	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 override
	The total number of tags, which can be limited to the tag type.

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

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

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

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

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

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

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

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

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

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

virtual bool	isTransient () const override

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

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 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 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 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 System &	getSystem (const std::string &var_name) override
	Returns the equation system containing the variable provided.

virtual void	addVariable (const std::string &var_type, const std::string &name, InputParameters &parameters, unsigned int nl_system_number)

virtual void	addAuxVariable (const std::string &var_type, const std::string &name, InputParameters &parameters)

virtual void	initAdaptivity ()

void	meshChanged (bool contract_mesh, bool clean_refinement_flags)

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

virtual void	prepareNonlocal (const THREAD_ID tid)

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

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

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

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

virtual void	prepareBlockNonlocal (unsigned int ivar, unsigned int jvar, const std::vector< dof_id_type > &idof_indices, const std::vector< dof_id_type > &jdof_indices, const THREAD_ID tid)

virtual void	prepareAssembly (const THREAD_ID tid) override

virtual void	prepareAssemblyNeighbor (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

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

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

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

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

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

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

void	reinitNeighbor (const Elem elem, unsigned int side, const THREAD_ID tid, const std::vector< Point > neighbor_reference_points)
	reinitialize neighbor routine

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	addResidual (const THREAD_ID tid) override

virtual void	addResidualNeighbor (const THREAD_ID tid) override

virtual void	addResidualLower (const THREAD_ID tid) override

virtual void	addCachedResidualDirectly (NumericVector< Number > &residual, const THREAD_ID tid)

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

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

virtual void	addJacobian (const THREAD_ID tid) override

virtual void	addJacobianNonlocal (const THREAD_ID tid)

virtual void	addJacobianNeighbor (const THREAD_ID tid) override

virtual void	addJacobianNeighborLowerD (const THREAD_ID tid) override

virtual void	addJacobianLowerD (const THREAD_ID tid) override

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

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

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

virtual void	cacheJacobianNonlocal (const THREAD_ID tid)

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

virtual void	updateGeomSearch (GeometricSearchData::GeometricSearchType type=GeometricSearchData::ALL) override
	update geometric search data

virtual GeometricSearchData &	geomSearchData () 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 void	onTimestepBegin () override

virtual void	onTimestepEnd () override

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

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.

void	undisplaceMesh ()
	Resets the displaced mesh to the reference mesh.

virtual LineSearch *	getLineSearch () override

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

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

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

virtual bool	computingScalingResidual () const override final
	Getter for whether we're computing the scaling residual.

virtual void	initialSetup () override

virtual void	timestepSetup () override

virtual void	customSetup (const ExecFlagType &exec_type) override

virtual void	residualSetup () override

virtual void	jacobianSetup () override

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

virtual std::size_t	numNonlinearSystems () const override

virtual std::size_t	numLinearSystems () const override

virtual std::size_t	numSolverSystems () const override

virtual unsigned int	currentNlSysNum () const override

virtual unsigned int	currentLinearSysNum () const override

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

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.

virtual bool	checkNonlocalCouplingRequirement () const override

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

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

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

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

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

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

virtual const MooseMesh &	mesh (bool use_displaced) const =0

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.

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.

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

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 void	setActiveElementalMooseVariables (const std::set< MooseVariableFieldBase * > &moose_vars, const THREAD_ID tid)
	Set the MOOSE variables to be reinited on each element.

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.

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

Moose::CoordinateSystemType	getCoordSystem (SubdomainID sid) const

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

virtual DiracKernelInfo &	diracKernelInfo ()

virtual Real	finalNonlinearResidual (const unsigned int nl_sys_num) const

virtual unsigned int	nNonlinearIterations (const unsigned int nl_sys_num) const

virtual unsigned int	nLinearIterations (const unsigned int nl_sys_num) const

virtual void	cacheResidual (const THREAD_ID tid)

virtual void	cacheResidualNeighbor (const THREAD_ID tid)

virtual void	addCachedResidual (const THREAD_ID tid)

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

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

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

virtual void	cacheJacobian (const THREAD_ID tid)

virtual void	cacheJacobianNeighbor (const THREAD_ID tid)

virtual void	addCachedJacobian (const THREAD_ID tid)

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)

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

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)
	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)
	reinitialize FE objects on a given neighbor element on a given side at a given set of reference points and then compute variable data.

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.

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.

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

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

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

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

virtual void	clearActiveFEVariableCoupleableMatrixTags (const THREAD_ID tid)

virtual void	clearActiveFEVariableCoupleableVectorTags (const THREAD_ID tid)

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

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

virtual void	clearActiveScalarVariableCoupleableMatrixTags (const THREAD_ID tid)

virtual void	clearActiveScalarVariableCoupleableVectorTags (const THREAD_ID tid)

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

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

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.

virtual void	automaticScaling (bool automatic_scaling)
	Automatic scaling setter.

bool	automaticScaling () const
	Automatic scaling getter.

void	hasScalingVector (const unsigned int nl_sys_num)
	Tells this problem that the assembly associated with the given nonlinear system number involves a scaling vector.

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

bool	havePRefinement () const
	Query whether p-refinement has been requested at any point during the simulation.

void	markFamilyPRefinement (const InputParameters &params)
	Mark a variable family for either disabling or enabling p-refinement with valid parameters of a variable.

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

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.

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.

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.

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

Protected Attributes
FEProblemBase &	_mproblem

MooseMesh &	_mesh

EquationSystems	_eq

MooseMesh &	_ref_mesh
	reference mesh

std::vector< std::string >	_displacements

std::vector< std::unique_ptr< DisplacedSystem > >	_displaced_solver_systems

std::unique_ptr< DisplacedSystem >	_displaced_aux

std::vector< const NumericVector< Number > * >	_nl_solution
	The nonlinear system solutions.

const NumericVector< Number > *	_aux_solution
	The auxiliary system solution.

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

GeometricSearchData	_geometric_search_data

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.


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
virtual std::pair< bool, unsigned int >	determineSolverSystem (const std::string &var_name, bool error_if_not_found=false) const override

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.


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

std::string	restrictionBoundaryCheckName (BoundaryID check_id)

Static Private Member Functions
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
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.

bool	_have_p_refinement
	Whether p-refinement has been requested at any point during the simulation.

std::unordered_map< FEFamily, bool >	_family_for_p_refinement
	Indicate whether a family is disabled for p-refinement.

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base
	The MooseBase that owns this interface.

const FEProblemBase *	_si_problem
	A pointer to FEProblem base.

Static Private Attributes
static const std::unordered_set< FEFamily >	_default_families_without_p_refinement
	The set of variable families by default disable p-refinement.

Friends
class	UpdateDisplacedMeshThread

class	Restartable

Detailed Description

Definition at line 37 of file DisplacedProblem.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

◆ TrueFunctorIs

enum class SubProblem::TrueFunctorIs

strongprivateinherited

Enumerator
UNSET
NONAD
AD

Definition at line 1144 of file SubProblem.h.

  {
    UNSET,
    NONAD,
    AD
  };

Constructor & Destructor Documentation

◆ DisplacedProblem() [1/2]

DisplacedProblem::DisplacedProblem ( DisplacedProblem && )

delete

◆ DisplacedProblem() [2/2]

DisplacedProblem::DisplacedProblem ( const InputParameters & parameters )

Definition at line 45 of file DisplacedProblem.C.

  : SubProblem(parameters),
    _mproblem(parameters.have_parameter<FEProblemBase *>("_fe_problem_base")
                  ? *getParam<FEProblemBase *>("_fe_problem_base")
                  : *getParam<FEProblem *>("_fe_problem")),
    _mesh(*getParam<MooseMesh *>("mesh")),
    _eq(_mesh),
    _ref_mesh(_mproblem.mesh()),
    _displacements(getParam<std::vector<std::string>>("displacements")),
    _geometric_search_data(*this, _mesh)
 
{
  // Disable refinement/coarsening in EquationSystems::reinit because we already do this ourselves
  _eq.disable_refine_in_reinit();
 
  // TODO: Move newAssemblyArray further up to SubProblem so that we can use it here
  unsigned int n_threads = libMesh::n_threads();
 
  _assembly.resize(n_threads);
  for (const auto nl_sys_num : make_range(_mproblem.numNonlinearSystems()))
  {
    _displaced_solver_systems.emplace_back(std::make_unique<DisplacedSystem>(
        *this,
        _mproblem,
        _mproblem.getNonlinearSystemBase(nl_sys_num),
        "displaced_" + _mproblem.getNonlinearSystemBase(nl_sys_num).name() + "_" +
            std::to_string(nl_sys_num),
        Moose::VAR_SOLVER));
    auto & displaced_nl = _displaced_solver_systems.back();
 
    for (unsigned int i = 0; i < n_threads; ++i)
      _assembly[i].emplace_back(std::make_unique<Assembly>(*displaced_nl, i));
  }
 
  _nl_solution.resize(_displaced_solver_systems.size(), nullptr);
 
  _displaced_aux =
      std::make_unique<DisplacedSystem>(*this,
                                        _mproblem,
                                        _mproblem.getAuxiliarySystem(),
                                        "displaced_" + _mproblem.getAuxiliarySystem().name(),
                                        Moose::VAR_AUXILIARY);
 
  // // Generally speaking, the mesh is prepared for use, and consequently remote elements are deleted
  // // well before our Problem(s) are constructed. Historically, in MooseMesh we have a bunch of
  // // needs_prepare type flags that make it so we never call prepare_for_use (and consequently
  // // delete_remote_elements) again. So the below line, historically, has had no impact. HOWEVER:
  // // I've added some code in SetupMeshCompleteAction for deleting remote elements post
  // // EquationSystems::init. If I execute that code without default ghosting, then I get > 40 MOOSE
  // // test failures, so we clearly have some simulations that are not yet covered properly by
  // // relationship managers. Until that is resolved, I am going to retain default geometric ghosting
  // if (!_default_ghosting)
  //   _mesh.getMesh().remove_ghosting_functor(_mesh.getMesh().default_ghosting());
 
  automaticScaling(_mproblem.automaticScaling());
 
  _mesh.setCoordData(_ref_mesh);
}

◆ ~DisplacedProblem()

DisplacedProblem::~DisplacedProblem ( )

default

Member Function Documentation

◆ _setCLIOption()

void Problem::_setCLIOption ( )

inlineinherited

For Internal Use.

Definition at line 32 of file Problem.h.

32{ _cli_option_found = true; }

Problem::_cli_option_found

bool _cli_option_found

True if the CLI option is found.

Definition Problem.h:52

◆ addAlgebraicGhostingFunctor()

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

inherited

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

Definition at line 1024 of file SubProblem.C.

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

◆ addAuxVariable()

void DisplacedProblem::addAuxVariable	(	const std::string &	var_type,
		const std::string &	name,
		InputParameters &	parameters
	)

virtual

Definition at line 597 of file DisplacedProblem.C.

{
  _displaced_aux->addVariable(var_type, name, parameters);
}

◆ addCachedJacobian()

void SubProblem::addCachedJacobian ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 1331 of file SubProblem.C.

{
  assembly(tid, currentNlSysNum()).addCachedJacobian(Assembly::GlobalDataKey{});
}

Referenced by FEProblemBase::addCachedJacobian().

◆ addCachedResidual()

void SubProblem::addCachedResidual ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 1310 of file SubProblem.C.

{
  assembly(tid, currentNlSysNum())
      .addCachedResiduals(Assembly::GlobalDataKey{}, currentResidualVectorTags());
}

Referenced by FEProblemBase::addCachedResidual().

◆ addCachedResidualDirectly()

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

virtual

Definition at line 967 of file DisplacedProblem.C.

{
  if (_displaced_solver_systems[currentNlSysNum()]->hasVector(
          _displaced_solver_systems[currentNlSysNum()]->timeVectorTag()))
    _assembly[tid][currentNlSysNum()]->addCachedResidualDirectly(
        residual,
        Assembly::GlobalDataKey{},
        getVectorTag(_displaced_solver_systems[currentNlSysNum()]->timeVectorTag()));
 
  if (_displaced_solver_systems[currentNlSysNum()]->hasVector(
          _displaced_solver_systems[currentNlSysNum()]->nonTimeVectorTag()))
    _assembly[tid][currentNlSysNum()]->addCachedResidualDirectly(
        residual,
        Assembly::GlobalDataKey{},
        getVectorTag(_displaced_solver_systems[currentNlSysNum()]->nonTimeVectorTag()));
 
  std::vector<VectorTag> extra_residual_vector_tags;
  extra_residual_vector_tags.reserve(currentResidualVectorTags().size());
  const auto time_tag = _displaced_solver_systems[currentNlSysNum()]->timeVectorTag();
  const auto non_time_tag = _displaced_solver_systems[currentNlSysNum()]->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][currentNlSysNum()]->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][currentNlSysNum()]->clearCachedResiduals(Assembly::GlobalDataKey{});
}

◆ addConsumedPropertyName()

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

inherited

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

Definition at line 737 of file SubProblem.C.

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

Referenced by MaterialPropertyInterface::addConsumedPropertyName().

◆ addCouplingGhostingFunctor()

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

inherited

Add a coupling functor to this problem's DofMaps.

Definition at line 1057 of file SubProblem.C.

{
  const auto num_nl_sys = numNonlinearSystems();
  if (!num_nl_sys)
    return;
 
  systemBaseNonlinear(0).system().get_dof_map().add_coupling_functor(coupling_gf, to_mesh);
  cloneCouplingGhostingFunctor(coupling_gf, to_mesh);
}

◆ 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 1393 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().

◆ addGhostedBoundary()

void DisplacedProblem::addGhostedBoundary ( BoundaryID boundary_id )

overridevirtual

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

Parameters

boundary_id Boundary ID

Implements SubProblem.

Definition at line 1174 of file DisplacedProblem.C.

{
  _mproblem.addGhostedBoundary(boundary_id);
}

◆ addGhostedElem()

void DisplacedProblem::addGhostedElem ( dof_id_type elem_id )

overridevirtual

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

Implements SubProblem.

Definition at line 1168 of file DisplacedProblem.C.

{
  _mproblem.addGhostedElem(elem_id);
}

◆ addJacobian()

void DisplacedProblem::addJacobian ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 1022 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->addJacobian(Assembly::GlobalDataKey{});
}

◆ addJacobianBlockNonlocal()

void DisplacedProblem::addJacobianBlockNonlocal	(	SparseMatrix< Number > &	jacobian,
		unsigned int	ivar,
		unsigned int	jvar,
		const libMesh::DofMap &	dof_map,
		const std::vector< dof_id_type > &	idof_indices,
		const std::vector< dof_id_type > &	jdof_indices,
		const std::set< TagID > &	tags,
		const THREAD_ID	tid
	)

Definition at line 1071 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->addJacobianBlockNonlocalTags(
      jacobian, ivar, jvar, dof_map, idof_indices, jdof_indices, Assembly::GlobalDataKey{}, tags);
}

◆ addJacobianBlockTags()

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

virtual

Definition at line 1058 of file DisplacedProblem.C.

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

◆ addJacobianLowerD()

void DisplacedProblem::addJacobianLowerD ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 1046 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->addJacobianLowerD(Assembly::GlobalDataKey{});
}

◆ addJacobianNeighbor() [1/3]

void DisplacedProblem::addJacobianNeighbor ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 1034 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->addJacobianNeighbor(Assembly::GlobalDataKey{});
}

◆ addJacobianNeighbor() [2/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

◆ addJacobianNeighbor() [3/3]

virtual void DisplacedProblem::addJacobianNeighbor	(	SparseMatrix< 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
	)

overridevirtual

◆ addJacobianNeighborLowerD()

void DisplacedProblem::addJacobianNeighborLowerD ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 1040 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->addJacobianNeighborLowerD(Assembly::GlobalDataKey{});
}

◆ addJacobianNonlocal()

void DisplacedProblem::addJacobianNonlocal ( const THREAD_ID tid )

virtual

Definition at line 1028 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->addJacobianNonlocal(Assembly::GlobalDataKey{});
}

◆ addMatrixTag()

TagID DisplacedProblem::addMatrixTag ( TagName tag_name )

overridevirtual

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

Definition at line 441 of file DisplacedProblem.C.

{
  return _mproblem.addMatrixTag(tag_name);
}

◆ addNotZeroedVectorTag()

void SubProblem::addNotZeroedVectorTag ( const TagID tag )

inherited

Adds a vector tag to the list of vectors that will not be zeroed when other tagged vectors are.

Parameters

tag	the TagID of the vector that will be manually managed

Definition at line 150 of file SubProblem.C.

{
  _not_zeroed_tagged_vectors.insert(tag);
}

Referenced by FEProblemBase::createTagVectors().

◆ 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 1356 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().

◆ addResidual()

void DisplacedProblem::addResidual ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 946 of file DisplacedProblem.C.

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

◆ addResidualLower()

void DisplacedProblem::addResidualLower ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 960 of file DisplacedProblem.C.

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

◆ addResidualNeighbor()

void DisplacedProblem::addResidualNeighbor ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 953 of file DisplacedProblem.C.

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

◆ addTimeIntegrator()

void DisplacedProblem::addTimeIntegrator ( )

Get the time integrators from the problem.

Definition at line 201 of file DisplacedProblem.C.

{
  for (const auto nl_sys_num : make_range(_mproblem.numNonlinearSystems()))
    _displaced_solver_systems[nl_sys_num]->copyTimeIntegrators(
        _mproblem.getNonlinearSystemBase(nl_sys_num));
  _displaced_aux->copyTimeIntegrators(_mproblem.getAuxiliarySystem());
}

◆ addVariable()

void DisplacedProblem::addVariable	(	const std::string &	var_type,
		const std::string &	name,
		InputParameters &	parameters,
		unsigned int	nl_system_number
	)

virtual

Definition at line 588 of file DisplacedProblem.C.

{
  _displaced_solver_systems[nl_system_number]->addVariable(var_type, name, parameters);
}

◆ addVectorTag()

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

overridevirtual

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

Definition at line 386 of file DisplacedProblem.C.

{
  return _mproblem.addVectorTag(tag_name, type);
}

◆ assembly() [1/2]

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

overridevirtual

Implements SubProblem.

Definition at line 1341 of file DisplacedProblem.C.

{
  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 & DisplacedProblem::assembly	(	const THREAD_ID	tid,
		const unsigned int	sys_num
	)

overridevirtual

Implements SubProblem.

Definition at line 1332 of file DisplacedProblem.C.

{
  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 setCurrentSubdomainID(), and setNeighborSubdomainID().

◆ automaticScaling() [1/2]

bool SubProblem::automaticScaling ( ) const

inherited

Automatic scaling getter.

Returns: A boolean representing whether we are performing automatic scaling

Definition at line 1163 of file SubProblem.C.

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

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

◆ automaticScaling() [2/2]

void SubProblem::automaticScaling ( bool automatic_scaling )

virtualinherited

Automatic scaling setter.

Parameters

automatic_scaling A boolean representing whether we are performing automatic scaling

Reimplemented in FEProblemBase, and FEProblemBase.

Definition at line 1156 of file SubProblem.C.

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

Referenced by MooseVariableBase::initialSetup().

◆ auxSys()

DisplacedSystem & DisplacedProblem::auxSys ( )

inline

Definition at line 59 of file DisplacedProblem.h.

59{ return *_displaced_aux; }

◆ bumpAllQRuleOrder()

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

Definition at line 141 of file DisplacedProblem.C.

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

Referenced by bumpAllQRuleOrder().

◆ bumpVolumeQRuleOrder()

void DisplacedProblem::bumpVolumeQRuleOrder	(	Order	order,
		SubdomainID	block
	)

Definition at line 133 of file DisplacedProblem.C.

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

Referenced by bumpVolumeQRuleOrder().

◆ cacheJacobian()

void SubProblem::cacheJacobian ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 1317 of file SubProblem.C.

{
  assembly(tid, currentNlSysNum()).cacheJacobian(Assembly::GlobalDataKey{});
  if (hasNonlocalCoupling())
    assembly(tid, currentNlSysNum()).cacheJacobianNonlocal(Assembly::GlobalDataKey{});
}

Referenced by FEProblemBase::cacheJacobian().

◆ cacheJacobianNeighbor()

void SubProblem::cacheJacobianNeighbor ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 1325 of file SubProblem.C.

{
  assembly(tid, currentNlSysNum()).cacheJacobianNeighbor(Assembly::GlobalDataKey{});
}

Referenced by FEProblemBase::cacheJacobianNeighbor().

◆ cacheJacobianNonlocal()

void DisplacedProblem::cacheJacobianNonlocal ( const THREAD_ID tid )

virtual

Definition at line 1052 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->cacheJacobianNonlocal(Assembly::GlobalDataKey{});
}

◆ cacheResidual()

void SubProblem::cacheResidual ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 1296 of file SubProblem.C.

{
  assembly(tid, currentNlSysNum())
      .cacheResidual(Assembly::GlobalDataKey{}, currentResidualVectorTags());
}

Referenced by FEProblemBase::cacheResidual().

◆ cacheResidualNeighbor()

void SubProblem::cacheResidualNeighbor ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 1303 of file SubProblem.C.

{
  assembly(tid, currentNlSysNum())
      .cacheResidualNeighbor(Assembly::GlobalDataKey{}, currentResidualVectorTags());
}

Referenced by FEProblemBase::cacheResidualNeighbor().

◆ 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 624 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 666 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().

◆ checkNonlocalCouplingRequirement()

bool DisplacedProblem::checkNonlocalCouplingRequirement ( ) const

overridevirtual

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

Implements SubProblem.

Definition at line 1428 of file DisplacedProblem.C.

{
  return _mproblem.checkNonlocalCouplingRequirement();
}

◆ checkResidualForNans()

virtual bool DisplacedProblem::checkResidualForNans ( ) const

inlineoverridevirtual

Whether to check residual for NaN/Inf values.

Implements SubProblem.

Definition at line 390 of file DisplacedProblem.h.

390{ return _mproblem.checkResidualForNans(); }

FEProblemBase::checkResidualForNans

virtual bool checkResidualForNans() const override

Whether to check residual for NaN/Inf values.

Definition FEProblemBase.h:231

◆ clearActiveElementalMooseVariables()

void SubProblem::clearActiveElementalMooseVariables ( const THREAD_ID tid )

virtualinherited

Clear the active elemental MooseVariableFieldBase.

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 MooseVariableFieldBase

Parameters

tid	The thread id

Reimplemented in FEProblemBase.

Definition at line 467 of file SubProblem.C.

{
  _has_active_elemental_moose_variables[tid] = 0;
  _active_elemental_moose_variables[tid].clear();
}

Referenced by FEProblemBase::clearActiveElementalMooseVariables().

◆ clearActiveFEVariableCoupleableMatrixTags()

void SubProblem::clearActiveFEVariableCoupleableMatrixTags ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 385 of file SubProblem.C.

{
  _active_fe_var_coupleable_matrix_tags[tid].clear();
}

Referenced by FEProblemBase::clearActiveFEVariableCoupleableMatrixTags().

◆ clearActiveFEVariableCoupleableVectorTags()

void SubProblem::clearActiveFEVariableCoupleableVectorTags ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 379 of file SubProblem.C.

{
  _active_fe_var_coupleable_vector_tags[tid].clear();
}

Referenced by FEProblemBase::clearActiveFEVariableCoupleableVectorTags().

◆ clearActiveScalarVariableCoupleableMatrixTags()

void SubProblem::clearActiveScalarVariableCoupleableMatrixTags ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 426 of file SubProblem.C.

{
  _active_sc_var_coupleable_matrix_tags[tid].clear();
}

Referenced by FEProblemBase::clearActiveScalarVariableCoupleableMatrixTags().

◆ clearActiveScalarVariableCoupleableVectorTags()

void SubProblem::clearActiveScalarVariableCoupleableVectorTags ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 420 of file SubProblem.C.

{
  _active_sc_var_coupleable_vector_tags[tid].clear();
}

Referenced by FEProblemBase::clearActiveScalarVariableCoupleableVectorTags().

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

◆ clearDiracInfo()

void DisplacedProblem::clearDiracInfo ( )

overridevirtual

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

Implements SubProblem.

Definition at line 940 of file DisplacedProblem.C.

{
  _dirac_kernel_info.clearPoints();
}

◆ 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 1002 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<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<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 1036 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<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<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().

◆ computingNonlinearResid() [1/2]

bool SubProblem::computingNonlinearResid ( ) const

inlineinherited

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

Definition at line 715 of file SubProblem.h.

715{ return _computing_nonlinear_residual; }

SubProblem::_computing_nonlinear_residual

bool _computing_nonlinear_residual

Whether the non-linear residual is being evaluated.

Definition SubProblem.h:1117

◆ computingNonlinearResid() [2/2]

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 in FEProblemBase, and FEProblemBase.

Definition at line 720 of file SubProblem.h.

  {
    _computing_nonlinear_residual = computing_nonlinear_residual;
  }

◆ computingPreSMOResidual()

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

overridevirtual

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

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

Implements SubProblem.

Definition at line 1198 of file DisplacedProblem.C.

{
  return _mproblem.computingPreSMOResidual(nl_sys_num);
}

◆ computingScalingJacobian()

bool DisplacedProblem::computingScalingJacobian ( ) const

finaloverridevirtual

Getter for whether we're computing the scaling jacobian.

Implements SubProblem.

Definition at line 1256 of file DisplacedProblem.C.

{
  return _mproblem.computingScalingJacobian();
}

◆ computingScalingResidual()

bool DisplacedProblem::computingScalingResidual ( ) const

finaloverridevirtual

Getter for whether we're computing the scaling residual.

Implements SubProblem.

Definition at line 1262 of file DisplacedProblem.C.

{
  return _mproblem.computingScalingResidual();
}

◆ connectControllableParams()

void MooseBase::connectControllableParams	(	const std::string &	parameter,
		const std::string &	object_type,
		const std::string &	object_name,
		const std::string &	object_parameter
	)		const

inherited

Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

Parameters

parameter	Name of the controllable parameter of this action
object_type	Type of the object added by this action.
object_name	Name of the object added by this action.
object_parameter	Name of the parameter of the object.

Definition at line 77 of file MooseBase.C.

{
  auto & factory = _app.getFactory();
  auto & ip_warehouse = _app.getInputParameterWarehouse();
 
  MooseObjectParameterName primary_name(uniqueName(), parameter);
  const auto base_type = factory.getValidParams(object_type).getBase();
  MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
  ip_warehouse.addControllableParameterConnection(primary_name, secondary_name);
 
  const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
  for (const auto & tag : tags)
  {
    if (!tag.empty())
    {
      // Only adds the parameter with the different control tags if the derived class
      // properly registers the parameter to its own syntax
      MooseObjectParameterName tagged_name(tag, name(), parameter);
      ip_warehouse.addControllableParameterConnection(
          tagged_name, secondary_name, /*error_on_empty=*/false);
    }
  }
}

◆ console()

const ConsoleStream & Problem::console ( ) const

inlineinherited

Return console handle.

Definition at line 48 of file Problem.h.

48{ return _console; }

ConsoleStreamInterface::_console

const ConsoleStream _console

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

Definition ConsoleStreamInterface.h:31

◆ converged()

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

inlinevirtualinherited

Eventually we want to convert this virtual over to taking a solver system number argument.

We will have to first convert apps to use solverSystemConverged, and then once that is done, we can change this signature. Then we can go through the apps again and convert back to this changed API

Definition at line 113 of file SubProblem.h.

113{ return solverSystemConverged(sys_num); }

SubProblem::solverSystemConverged

virtual bool solverSystemConverged(const unsigned int sys_num)

Definition SubProblem.h:100

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

◆ couplingMatrix()

const CouplingMatrix * DisplacedProblem::couplingMatrix ( const unsigned int nl_sys_num ) const

overridevirtual

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

Implements SubProblem.

Definition at line 1250 of file DisplacedProblem.C.

{
  return _mproblem.couplingMatrix(nl_sys_num);
}

◆ createQRules()

void DisplacedProblem::createQRules	(	QuadratureType	type,
		Order	order,
		Order	volume_order,
		Order	face_order,
		SubdomainID	block,
		bool	allow_negative_qweights = `true`
	)

virtual

Definition at line 119 of file DisplacedProblem.C.

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

Referenced by createQRules().

◆ currentLinearSysNum()

unsigned int DisplacedProblem::currentLinearSysNum ( ) const

overridevirtual

Returns: the current linear system number

Implements SubProblem.

Definition at line 611 of file DisplacedProblem.C.

{
  return _mproblem.currentLinearSysNum();
}

◆ currentlyComputingJacobian()

const bool & SubProblem::currentlyComputingJacobian ( ) const

inlineinherited

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

Definition at line 692 of file SubProblem.h.

692{ return _currently_computing_jacobian; };

SubProblem::_currently_computing_jacobian

bool _currently_computing_jacobian

Flag to determine whether the problem is currently computing Jacobian.

Definition SubProblem.h:1111

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

◆ currentlyComputingResidual()

const bool & SubProblem::currentlyComputingResidual ( ) const

inlineinherited

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

Definition at line 728 of file SubProblem.h.

728{ return _currently_computing_residual; }

SubProblem::_currently_computing_residual

bool _currently_computing_residual

Whether the residual is being evaluated.

Definition SubProblem.h:1120

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

{
  return _currently_computing_residual_and_jacobian;
}

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

◆ currentNlSysNum()

unsigned int DisplacedProblem::currentNlSysNum ( ) const

overridevirtual

Returns: the current nonlinear system number

Implements SubProblem.

Definition at line 605 of file DisplacedProblem.C.

{
  return _mproblem.currentNlSysNum();
}

Referenced by addCachedResidualDirectly(), addJacobian(), addJacobianBlockNonlocal(), addJacobianBlockTags(), addJacobianLowerD(), addJacobianNeighbor(), addJacobianNeighborLowerD(), addJacobianNonlocal(), addResidual(), addResidualLower(), addResidualNeighbor(), cacheJacobianNonlocal(), prepare(), prepareAssembly(), prepareAssemblyNeighbor(), prepareBlockNonlocal(), prepareFaceShapes(), prepareNeighborShapes(), prepareNonlocal(), prepareShapes(), reinitDirac(), reinitElemNeighborAndLowerD(), reinitOffDiagScalars(), setResidual(), and setResidualNeighbor().

◆ currentResidualVectorTags()

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

overridevirtual

Return the residual vector tags we are currently computing.

Implements SubProblem.

Definition at line 1368 of file DisplacedProblem.C.

{
  return _mproblem.currentResidualVectorTags();
}

Referenced by addCachedResidualDirectly(), addResidual(), addResidualLower(), and addResidualNeighbor().

◆ customSetup()

void DisplacedProblem::customSetup ( const ExecFlagType & exec_type )

overridevirtual

Reimplemented from SubProblem.

Definition at line 1288 of file DisplacedProblem.C.

{
  SubProblem::customSetup(exec_type);
 
  for (auto & nl : _displaced_solver_systems)
    nl->customSetup(exec_type);
  _displaced_aux->customSetup(exec_type);
}

◆ defaultGhosting()

bool SubProblem::defaultGhosting ( )

inlineinherited

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

Definition at line 144 of file SubProblem.h.

144{ return _default_ghosting; }

SubProblem::_default_ghosting

bool _default_ghosting

Whether or not to use default libMesh coupling.

Definition SubProblem.h:1105

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

◆ determineSolverSystem()

std::pair< bool, unsigned int > DisplacedProblem::determineSolverSystem	(	const std::string &	var_name,
		bool	error_if_not_found = `false`
	)		const

overrideprivatevirtual

Returns: whether a given variable name is in the solver systems (reflected by the first member of the returned pair which is a boolean) and if so, what solver system number it is in (the second member of the returned pair; if the variable is not in the solver systems, then this will be an invalid unsigned integer)

Implements SubProblem.

Definition at line 1325 of file DisplacedProblem.C.

{
  return _mproblem.determineSolverSystem(var_name, error_if_not_found);
}

◆ diracKernelInfo()

DiracKernelInfo & SubProblem::diracKernelInfo ( )

virtualinherited

Definition at line 749 of file SubProblem.C.

{
  return _dirac_kernel_info;
}

◆ doingPRefinement()

bool SubProblem::doingPRefinement ( ) const

inherited

Returns: whether we're doing p-refinement

Definition at line 1366 of file SubProblem.C.

{
  return mesh().doingPRefinement();
}

Referenced by FEProblemBase::meshChanged().

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 49 of file MooseObject.h.

49{ return _enabled; }

MooseObject::_enabled

const bool & _enabled

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

Definition MooseObject.h:71

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

◆ errorPrefix()

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

inlineinherited

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

Definition at line 264 of file MooseBase.h.

264{ return messagePrefix(); }

◆ es()

virtual EquationSystems & DisplacedProblem::es ( )

inlineoverridevirtual

Implements SubProblem.

Definition at line 48 of file DisplacedProblem.h.

48{ return _eq; }

Referenced by DisplacedProblem::UpdateDisplacedMeshThread::init().

◆ finalNonlinearResidual()

Real SubProblem::finalNonlinearResidual ( const unsigned int nl_sys_num ) const

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 755 of file SubProblem.C.

{
  return 0;
}

Referenced by Residual::getValue().

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

◆ geomSearchData()

virtual GeometricSearchData & DisplacedProblem::geomSearchData ( )

inlineoverridevirtual

Implements SubProblem.

Definition at line 316 of file DisplacedProblem.h.

316{ return _geometric_search_data; }

◆ getActiveElementalMooseVariables()

const std::set< MooseVariableFEBase * > & SubProblem::getActiveElementalMooseVariables ( const THREAD_ID tid ) const

virtualinherited

Get the MOOSE variables to be reinited on each element.

Parameters

tid	The thread id

Definition at line 455 of file SubProblem.C.

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

{
  return _active_fe_var_coupleable_matrix_tags[tid];
}

◆ getActiveFEVariableCoupleableVectorTags()

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

inherited

Definition at line 397 of file SubProblem.C.

{
  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 432 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 438 of file SubProblem.C.

{
  return _active_sc_var_coupleable_vector_tags[tid];
}

◆ getActualFieldVariable()

MooseVariableFieldBase & DisplacedProblem::getActualFieldVariable	(	const THREAD_ID	tid,
		const std::string &	var_name
	)

overridevirtual

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

Implements SubProblem.

Definition at line 515 of file DisplacedProblem.C.

{
  for (auto & nl : _displaced_solver_systems)
    if (nl->hasVariable(var_name))
      return nl->getActualFieldVariable<Real>(tid, var_name);
  if (_displaced_aux->hasVariable(var_name))
    return _displaced_aux->getActualFieldVariable<Real>(tid, var_name);
 
  mooseError("No variable with name '" + var_name + "'");
}

◆ getArrayVariable()

ArrayMooseVariable & DisplacedProblem::getArrayVariable	(	const THREAD_ID	tid,
		const std::string &	var_name
	)

overridevirtual

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

Implements SubProblem.

Definition at line 539 of file DisplacedProblem.C.

{
  for (auto & nl : _displaced_solver_systems)
    if (nl->hasVariable(var_name))
      return nl->getFieldVariable<RealEigenVector>(tid, var_name);
  if (_displaced_aux->hasVariable(var_name))
    return _displaced_aux->getFieldVariable<RealEigenVector>(tid, var_name);
 
  mooseError("No variable with name '" + var_name + "'");
}

◆ getAxisymmetricRadialCoord()

unsigned int SubProblem::getAxisymmetricRadialCoord ( ) const

inherited

Returns the desired radial direction for RZ coordinate transformation.

Returns: The coordinate direction for the radial direction

Definition at line 797 of file SubProblem.C.

{
  return mesh().getAxisymmetricRadialCoord();
}

◆ getBase()

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

inlineinherited

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

Definition at line 147 of file MooseBase.h.

147{ return _pars.getBase(); }

InputParameters::getBase

const std::string & getBase() const

Definition InputParameters.C:505

Referenced by Factory::copyConstruct(), and MooseBase::uniqueParameterName().

◆ getCheckedPointerParam()

template<typename T >

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

inherited

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

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

Definition at line 450 of file MooseBase.h.

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

◆ getConsumedPropertyMap()

const std::map< MooseObjectName, std::set< std::string > > & SubProblem::getConsumedPropertyMap ( ) const

inherited

Return the map that tracks the object with consumed material properties.

Definition at line 743 of file SubProblem.C.

{
  return _consumed_material_properties;
}

Referenced by MaterialPropertyDebugOutput::output().

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

◆ 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 DisplacedProblem::getDiracElements ( std::set< const Elem * > & elems )

overridevirtual

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

Implements SubProblem.

Definition at line 934 of file DisplacedProblem.C.

{
  elems = _dirac_kernel_info.getElements();
}

◆ getDisplacementVarNames()

const std::vector< std::string > & DisplacedProblem::getDisplacementVarNames ( ) const

inline

Definition at line 74 of file DisplacedProblem.h.

74{ return _displacements; }

◆ 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 1232 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 static_cast<Moose::Functor<T> &>(*(requested_functor_is_ad
                                                  ? std::get<2>(emplace_ret->second)
                                                  : std::get<1>(emplace_ret->second)));
  }
  else
  {
    typedef T NonADType;
    typedef typename Moose::ADType<T>::type ADType;
 
    auto emplace_ret =
        functors.emplace("wraps_" + name,
                         std::make_tuple(SubProblem::TrueFunctorIs::UNSET,
                                         std::make_unique<Moose::Functor<NonADType>>(
                                             std::make_unique<Moose::NullFunctor<NonADType>>()),
                                         std::make_unique<Moose::Functor<ADType>>(
                                             std::make_unique<Moose::NullFunctor<ADType>>())));
 
    return static_cast<Moose::Functor<T> &>(*(requested_functor_is_ad
                                                  ? std::get<2>(emplace_ret->second)
                                                  : std::get<1>(emplace_ret->second)));
  }
}

Referenced by FunctorInterface::getFunctorByName().

◆ getHitNode() [1/2]

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

inlineinherited

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

Definition at line 136 of file MooseBase.h.

136{ return getHitNode(_pars); }

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

◆ getHitNode() [2/2]

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

staticprivateinherited

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

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

Definition at line 167 of file MooseBase.C.

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

◆ getLineSearch()

LineSearch * DisplacedProblem::getLineSearch ( )

overridevirtual

Implements SubProblem.

Definition at line 1244 of file DisplacedProblem.C.

{
  return _mproblem.getLineSearch();
}

◆ getMaterialPropertyBlockNames()

std::vector< SubdomainName > SubProblem::getMaterialPropertyBlockNames ( const std::string & prop_name )

virtualinherited

Get a vector of block id equivalences that the material property is defined on.

Definition at line 490 of file SubProblem.C.

{
  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 474 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 526 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 542 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().

◆ getMatrixTagID()

TagID DisplacedProblem::getMatrixTagID ( const TagName & tag_name ) const

overridevirtual

Get a TagID from a TagName.

Reimplemented from SubProblem.

Definition at line 447 of file DisplacedProblem.C.

{
  return _mproblem.getMatrixTagID(tag_name);
}

◆ getMatrixTags()

virtual std::map< TagName, TagID > & SubProblem::getMatrixTags ( )

inlinevirtualinherited

Return all matrix tags in the system, where a tag is represented by a map from name to ID.

Definition at line 253 of file SubProblem.h.

253{ return _matrix_tag_name_to_tag_id; }

SubProblem::_matrix_tag_name_to_tag_id

std::map< TagName, TagID > _matrix_tag_name_to_tag_id

The currently declared tags.

Definition SubProblem.h:1056

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

◆ getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

87{ return _app; }

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), ReporterTransferInterface::checkHasReporterValue(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Coupleable::Coupleable(), MortarInterfaceWarehouse::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), FEProblemBase::getDistribution(), FEProblemBase::getFunction(), FEProblemBase::getFVInterpolationMethod(), FEProblemBase::getMultiApp(), FEProblemBase::getSampler(), DefaultConvergenceBase::getSharedExecutionerParam(), FEProblemBase::getUserObjectBase(), FEProblemBase::getVectorPostprocessorObjectByName(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), Moose::PetscSupport::PetscOptionsScope::PetscOptionsScope(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

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

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

◆ 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 + "'");
}

◆ getScalarVariable()

MooseVariableScalar & DisplacedProblem::getScalarVariable	(	const THREAD_ID	tid,
		const std::string &	var_name
	)

overridevirtual

Returns the scalar variable reference from whichever system contains it.

Implements SubProblem.

Definition at line 563 of file DisplacedProblem.C.

{
  for (auto & nl : _displaced_solver_systems)
    if (nl->hasScalarVariable(var_name))
      return nl->getScalarVariable(tid, var_name);
  if (_displaced_aux->hasScalarVariable(var_name))
    return _displaced_aux->getScalarVariable(tid, var_name);
 
  mooseError("No variable with name '" + var_name + "'");
}

◆ getSharedPtr() [1/2]

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

inherited

Get another shared pointer to this object that has the same ownership group.

Wrapper around shared_from_this().

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

◆ getStandardVariable()

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

overridevirtual

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

Implements SubProblem.

Definition at line 503 of file DisplacedProblem.C.

{
  for (auto & nl : _displaced_solver_systems)
    if (nl->hasVariable(var_name))
      return nl->getFieldVariable<Real>(tid, var_name);
  if (_displaced_aux->hasVariable(var_name))
    return _displaced_aux->getFieldVariable<Real>(tid, var_name);
 
  mooseError("No variable with name '" + var_name + "'");
}

◆ getSystem()

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

overridevirtual

Returns the equation system containing the variable provided.

Implements SubProblem.

Definition at line 575 of file DisplacedProblem.C.

{
  for (const auto sys_num : make_range(_eq.n_systems()))
  {
    auto & sys = _eq.get_system(sys_num);
    if (sys.has_variable(var_name))
      return sys;
  }
 
  mooseError("Unable to find a system containing the variable " + var_name);
}

◆ getVariable() [1/3]

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

inlinevirtual

Reimplemented from SubProblem.

Definition at line 279 of file SubProblem.h.

  {
    return const_cast<MooseVariableFieldBase &>(const_cast<const SubProblem *>(this)->getVariable(
        tid, var_name, expected_var_type, expected_var_field_type));
  }

◆ getVariable() [2/3]

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

overridevirtual

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

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

Implements SubProblem.

Definition at line 489 of file DisplacedProblem.C.

{
  return getVariableHelper(tid,
                           var_name,
                           expected_var_type,
                           expected_var_field_type,
                           _displaced_solver_systems,
                           *_displaced_aux);
}

Referenced by init().

◆ getVariable() [3/3]

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

virtual

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

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

Implements SubProblem.

◆ getVariableHelper() [1/2]

template<typename T >

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

protectedinherited

Helper function called by getVariable that handles the logic for checking whether Variables of the requested type are available.

Referenced by 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 819 of file SubProblem.C.

{
  // Eventual return value
  MooseVariableFEBase * var = nullptr;
 
  const auto [var_in_sys, sys_num] = determineSolverSystem(var_name);
 
  // First check that the variable is found on the expected system.
  if (expected_var_type == Moose::VarKindType::VAR_ANY)
  {
    if (var_in_sys)
      var = &(systems[sys_num]->getVariable(tid, var_name));
    else if (aux.hasVariable(var_name))
      var = &(aux.getVariable(tid, var_name));
    else
      mooseError("Unknown variable " + var_name);
  }
  else if (expected_var_type == Moose::VarKindType::VAR_SOLVER && var_in_sys &&
           systems[sys_num]->hasVariable(var_name))
    var = &(systems[sys_num]->getVariable(tid, var_name));
  else if (expected_var_type == Moose::VarKindType::VAR_AUXILIARY && aux.hasVariable(var_name))
    var = &(aux.getVariable(tid, var_name));
  else
  {
    std::string expected_var_type_string =
        (expected_var_type == Moose::VarKindType::VAR_SOLVER ? "nonlinear" : "auxiliary");
    mooseError("No ",
               expected_var_type_string,
               " variable named ",
               var_name,
               " found. "
               "Did you specify an auxiliary variable when you meant to specify a nonlinear "
               "variable (or vice-versa)?");
  }
 
  // Now make sure the var found has the expected field type.
  if ((expected_var_field_type == Moose::VarFieldType::VAR_FIELD_ANY) ||
      (expected_var_field_type == var->fieldType()))
    return *var;
  else
  {
    std::string expected_var_field_type_string =
        MooseUtils::toLower(Moose::stringify(expected_var_field_type));
    std::string var_field_type_string = MooseUtils::toLower(Moose::stringify(var->fieldType()));
 
    mooseError("No ",
               expected_var_field_type_string,
               " variable named ",
               var_name,
               " found. "
               "Did you specify a ",
               var_field_type_string,
               " variable when you meant to specify a ",
               expected_var_field_type_string,
               " variable?");
  }
}

◆ getVectorTag()

const VectorTag & DisplacedProblem::getVectorTag ( const TagID tag_id ) const

overridevirtual

Get a VectorTag from a TagID.

Reimplemented from SubProblem.

Definition at line 393 of file DisplacedProblem.C.

{
  return _mproblem.getVectorTag(tag_id);
}

Referenced by addCachedResidualDirectly(), setResidual(), and setResidualNeighbor().

◆ getVectorTagID()

TagID DisplacedProblem::getVectorTagID ( const TagName & tag_name ) const

overridevirtual

Get a TagID from a TagName.

Reimplemented from SubProblem.

Definition at line 399 of file DisplacedProblem.C.

{
  return _mproblem.getVectorTagID(tag_name);
}

◆ getVectorTags() [1/2]

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

overridevirtual

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

Definition at line 429 of file DisplacedProblem.C.

{
  return _mproblem.getVectorTags(type);
}

◆ getVectorTags() [2/2]

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

inherited

Definition at line 173 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(), getVectorTags(), SubProblem::numVectorTags(), ComputeMortarFunctor::operator()(), and FEProblemBase::setCurrentResidualVectorTags().

◆ getVectorVariable()

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

overridevirtual

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

Implements SubProblem.

Definition at line 527 of file DisplacedProblem.C.

{
  for (auto & nl : _displaced_solver_systems)
    if (nl->hasVariable(var_name))
      return nl->getFieldVariable<RealVectorValue>(tid, var_name);
  if (_displaced_aux->hasVariable(var_name))
    return _displaced_aux->getFieldVariable<RealVectorValue>(tid, var_name);
 
  mooseError("No variable with name '" + var_name + "'");
}

◆ ghostedElems()

std::set< dof_id_type > & DisplacedProblem::ghostedElems ( )

overridevirtual

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

Returns: The list

Reimplemented from SubProblem.

Definition at line 113 of file DisplacedProblem.C.

{
  return _mproblem.ghostedElems();
}

◆ ghostGhostedBoundaries()

void DisplacedProblem::ghostGhostedBoundaries ( )

overridevirtual

Causes the boundaries added using addGhostedBoundary to actually be ghosted.

Implements SubProblem.

Definition at line 1180 of file DisplacedProblem.C.

{
  _mproblem.ghostGhostedBoundaries();
}

◆ hasActiveElementalMooseVariables()

bool SubProblem::hasActiveElementalMooseVariables ( const THREAD_ID tid ) const

virtualinherited

Whether or not a list of active elemental moose variables has been set.

Returns: True if there has been a list of active elemental moose variables set, False otherwise

Definition at line 461 of file SubProblem.C.

{
  return _has_active_elemental_moose_variables[tid];
}

Referenced by SystemBase::prepare(), SystemBase::prepareFace(), and SystemBase::reinitElem().

◆ hasAuxiliaryVariable()

bool SubProblem::hasAuxiliaryVariable ( const std::string & var_name ) const

virtualinherited

Whether or not this problem has this auxiliary variable.

Definition at line 812 of file SubProblem.C.

{
  return systemBaseAuxiliary().hasVariable(var_name);
}

Referenced by FixedPointSolve::findTransformedSystem(), FunctorChangeFunctorMaterialTempl< is_ad >::FunctorChangeFunctorMaterialTempl(), SubProblem::getFunctor(), and NearestNodeValueAux::NearestNodeValueAux().

◆ hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

Returns: Whether or not this object has a registered base (set via InputParameters::registerBase())

Definition at line 142 of file MooseBase.h.

142{ return _pars.hasBase(); }

InputParameters::hasBase

bool hasBase() const

Definition InputParameters.C:499

◆ hasBlockMaterialProperty()

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

virtualinherited

Check if a material property is defined on a block.

Definition at line 512 of file SubProblem.C.

{
  auto it = _map_block_material_props.find(bid);
  if (it == _map_block_material_props.end())
    return false;
 
  if (it->second.count(prop_name) > 0)
    return true;
  else
    return false;
}

◆ hasBoundaryMaterialProperty()

bool SubProblem::hasBoundaryMaterialProperty	(	BoundaryID	boundary_id,
		const std::string &	prop_name
	)

virtualinherited

Check if a material property is defined on a block.

Definition at line 571 of file SubProblem.C.

{
  auto it = _map_boundary_material_props.find(bid);
  if (it == _map_boundary_material_props.end())
    return false;
 
  if (it->second.count(prop_name) > 0)
    return true;
  else
    return false;
}

◆ 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 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 1338 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());
}

◆ hasLinearVariable()

bool SubProblem::hasLinearVariable ( const std::string & var_name ) const

virtualinherited

Whether or not this problem has this linear variable.

Definition at line 803 of file SubProblem.C.

{
  for (const auto i : make_range(numLinearSystems()))
    if (systemBaseLinear(i).hasVariable(var_name))
      return true;
  return false;
}

Referenced by SubProblem::getFunctor().

◆ hasNonlocalCoupling()

bool DisplacedProblem::hasNonlocalCoupling ( ) const

overridevirtual

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 1398 of file DisplacedProblem.C.

{
  return _mproblem.hasNonlocalCoupling();
}

◆ hasScalarVariable()

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

overridevirtual

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

Implements SubProblem.

Definition at line 551 of file DisplacedProblem.C.

{
  for (auto & nl : _displaced_solver_systems)
    if (nl->hasScalarVariable(var_name))
      return true;
  if (_displaced_aux->hasScalarVariable(var_name))
    return true;
 
  return false;
}

◆ hasScalingVector()

void SubProblem::hasScalingVector ( const unsigned int nl_sys_num )

inherited

Tells this problem that the assembly associated with the given nonlinear system number involves a scaling vector.

Definition at line 1171 of file SubProblem.C.

{
  for (const THREAD_ID tid : make_range(libMesh::n_threads()))
    assembly(tid, nl_sys_num).hasScalingVector();
}

Referenced by SystemBase::addScalingVector().

◆ hasVariable()

bool DisplacedProblem::hasVariable ( const std::string & var_name ) const

overridevirtual

Whether or not this problem has the variable.

Implements SubProblem.

Definition at line 477 of file DisplacedProblem.C.

{
  for (auto & nl : _displaced_solver_systems)
    if (nl->hasVariable(var_name))
      return true;
  if (_displaced_aux->hasVariable(var_name))
    return true;
 
  return false;
}

◆ haveADObjects() [1/3]

bool SubProblem::haveADObjects ( ) const

inline

Method for reading wehther we have any ad objects.

Definition at line 779 of file SubProblem.h.

779{ return _have_ad_objects; }

SubProblem::_have_ad_objects

bool _have_ad_objects

AD flag indicating whether any AD objects have been added.

Definition SubProblem.h:1129

◆ haveADObjects() [2/3]

virtual void SubProblem::haveADObjects ( bool have_ad_objects )

inlinevirtual

Method for setting whether we have any ad objects.

Reimplemented from SubProblem.

Definition at line 775 of file SubProblem.h.

775{ _have_ad_objects = have_ad_objects; }

◆ haveADObjects() [3/3]

void DisplacedProblem::haveADObjects ( bool have_ad_objects )

overridevirtual

Method for setting whether we have any ad objects.

Reimplemented from SubProblem.

Definition at line 1318 of file DisplacedProblem.C.

{
  _have_ad_objects = have_ad_objects;
  _mproblem.SubProblem::haveADObjects(have_ad_objects);
}

◆ haveDisplaced()

virtual bool DisplacedProblem::haveDisplaced ( ) const

inlinefinaloverridevirtual

Whether we have a displaced problem in our simulation.

Implements SubProblem.

Definition at line 355 of file DisplacedProblem.h.

355{ return true; }

◆ haveFV()

bool DisplacedProblem::haveFV ( ) const

overridevirtual

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

Implements SubProblem.

Definition at line 1392 of file DisplacedProblem.C.

{
  return _mproblem.haveFV();
}

Referenced by init(), and updateMesh().

◆ havePRefinement()

bool SubProblem::havePRefinement ( ) const

inlineinherited

Query whether p-refinement has been requested at any point during the simulation.

Definition at line 1024 of file SubProblem.h.

1024{ return _have_p_refinement; }

SubProblem::_have_p_refinement

bool _have_p_refinement

Whether p-refinement has been requested at any point during the simulation.

Definition SubProblem.h:1220

Referenced by AdvancedOutput::initAvailableLists(), and FEProblemBase::meshChanged().

◆ init()

void DisplacedProblem::init ( )

overridevirtual

Implements Problem.

Definition at line 149 of file DisplacedProblem.C.

{
  for (THREAD_ID tid = 0; tid < libMesh::n_threads(); ++tid)
  {
    for (const auto nl_sys_num : index_range(_displaced_solver_systems))
      _assembly[tid][nl_sys_num]->init(_mproblem.couplingMatrix(nl_sys_num));
 
    for (const auto nl_sys_num : index_range(_displaced_solver_systems))
    {
      std::vector<std::pair<unsigned int, unsigned short>> disp_numbers_and_directions;
      for (const auto direction : index_range(_displacements))
      {
        const auto & disp_string = _displacements[direction];
        const auto & disp_variable = getVariable(tid, disp_string);
        if (disp_variable.sys().number() == nl_sys_num)
          disp_numbers_and_directions.push_back(
              std::make_pair(disp_variable.number(), cast_int<unsigned short>(direction)));
      }
      _assembly[tid][nl_sys_num]->assignDisplacements(std::move(disp_numbers_and_directions));
    }
  }
 
  for (auto & nl : _displaced_solver_systems)
  {
    nl->dofMap().attach_extra_send_list_function(&extraSendList, nl.get());
    nl->preInit();
  }
 
  _displaced_aux->dofMap().attach_extra_send_list_function(&extraSendList, _displaced_aux.get());
  _displaced_aux->preInit();
 
  {
    TIME_SECTION("eq::init", 2, "Initializing Displaced Equation System");
    _eq.init();
  }
 
  for (auto & nl : _displaced_solver_systems)
    nl->postInit();
  _displaced_aux->postInit();
 
  _mesh.meshChanged();
 
  if (haveFV())
    _mesh.setupFiniteVolumeMeshData();
}

Referenced by init().

◆ initAdaptivity()

void DisplacedProblem::initAdaptivity ( )

virtual

Definition at line 196 of file DisplacedProblem.C.

197{

198}

◆ initialSetup()

void DisplacedProblem::initialSetup ( )

overridevirtual

Reimplemented from SubProblem.

Definition at line 1268 of file DisplacedProblem.C.

{
  SubProblem::initialSetup();
 
  for (auto & nl : _displaced_solver_systems)
    nl->initialSetup();
  _displaced_aux->initialSetup();
}

◆ isKokkosObject()

bool MooseObject::isKokkosObject ( ) const

inlineinherited

Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.

Definition at line 63 of file MooseObject.h.

63{ return parameters().isKokkosObject(); }

InputParameters::isKokkosObject

bool isKokkosObject() const

Returns whether this InputParameters belongs to a Kokkos object Checks whether MooseBase::kokkos_obje...

Definition InputParameters.C:433

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

{
  return _material_property_requested.find(prop_name) != _material_property_requested.end();
}

◆ isParamSetByUser()

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

inlineinherited

Test if the supplied parameter is set by a user, as opposed to not set or set to default.

Parameters

name	The name of the parameter to test

Definition at line 205 of file MooseBase.h.

  {
    return _pars.isParamSetByUser(name);
  }

Referenced by DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), MFEMMesh::buildMesh(), MFEMBoundarySubMesh::buildSubMesh(), MFEMDomainSubMesh::buildSubMesh(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), FileMesh::FileMesh(), FullSolveMultiApp::FullSolveMultiApp(), OrientSurfaceMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), MFEMMesh::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MFEMVariable::MFEMVariable(), MortarConstraintBase::MortarConstraintBase(), 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(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SmoothMeshGenerator::SmoothMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SurfaceSubdomainsFromAllNormalsGenerator::SurfaceSubdomainsFromAllNormalsGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

◆ isParamValid()

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

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 199 of file MooseBase.h.

199{ return _pars.isParamValid(name); }

InputParameters::isParamValid

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

This method returns parameters that have been initialized in one fashion or another,...

Definition InputParameters.C:386

◆ isSolveTerminationRequested()

virtual bool Problem::isSolveTerminationRequested ( ) const

inlinevirtualinherited

Check of termination has been requested.

This should be called by transient Executioners in the keepGoing() member.

Definition at line 43 of file Problem.h.

43{ return _termination_requested; };

Problem::_termination_requested

bool _termination_requested

True if termination of the solve has been requested.

Definition Problem.h:58

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

◆ isTransient()

bool DisplacedProblem::isTransient ( ) const

overridevirtual

Implements SubProblem.

Definition at line 107 of file DisplacedProblem.C.

{
  return _mproblem.isTransient();
}

◆ jacobianSetup()

void DisplacedProblem::jacobianSetup ( )

overridevirtual

Reimplemented from SubProblem.

Definition at line 1308 of file DisplacedProblem.C.

{
  SubProblem::jacobianSetup();
 
  for (auto & nl : _displaced_solver_systems)
    nl->jacobianSetup();
  _displaced_aux->jacobianSetup();
}

◆ linearSysNum()

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

overridevirtual

Returns: the linear system number corresponding to the provided linear_sys_name

Implements SubProblem.

Definition at line 1410 of file DisplacedProblem.C.

{
  return _mproblem.linearSysNum(sys_name);
}

◆ markFamilyPRefinement()

void SubProblem::markFamilyPRefinement ( const InputParameters & params )

inherited

Mark a variable family for either disabling or enabling p-refinement with valid parameters of a variable.

Definition at line 1372 of file SubProblem.C.

{
  auto family = Utility::string_to_enum<FEFamily>(params.get<MooseEnum>("family"));
  bool flag = _default_families_without_p_refinement.count(family);
  if (params.isParamValid("disable_p_refinement"))
    flag = params.get<bool>("disable_p_refinement");
 
  auto [it, inserted] = _family_for_p_refinement.emplace(family, flag);
  if (!inserted && flag != it->second)
    mooseError("'disable_p_refinement' not set consistently for variables in ", family);
}

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

◆ markMatPropRequested()

void SubProblem::markMatPropRequested ( const std::string & prop_name )

virtualinherited

Helper method for adding a material property name to the _material_property_requested set.

Definition at line 725 of file SubProblem.C.

{
  _material_property_requested.insert(prop_name);
}

Referenced by MaterialPropertyInterface::markMatPropRequested(), and MaterialBase::markMatPropRequested().

◆ matrixTagExists() [1/2]

bool DisplacedProblem::matrixTagExists ( const TagName & tag_name ) const

overridevirtual

Check to see if a particular Tag exists.

Reimplemented from SubProblem.

Definition at line 459 of file DisplacedProblem.C.

{
  return _mproblem.matrixTagExists(tag_name);
}

◆ matrixTagExists() [2/2]

bool DisplacedProblem::matrixTagExists ( TagID tag_id ) const

overridevirtual

Check to see if a particular Tag exists.

Reimplemented from SubProblem.

Definition at line 465 of file DisplacedProblem.C.

{
  return _mproblem.matrixTagExists(tag_id);
}

◆ matrixTagName()

TagName DisplacedProblem::matrixTagName ( TagID tag )

overridevirtual

Retrieve the name associated with a TagID.

Reimplemented from SubProblem.

Definition at line 453 of file DisplacedProblem.C.

{
  return _mproblem.matrixTagName(tag);
}

◆ mesh() [1/4]

virtual const MooseMesh & DisplacedProblem::mesh ( ) const

inlineoverridevirtual

Implements SubProblem.

Definition at line 50 of file DisplacedProblem.h.

50{ return _mesh; }

◆ mesh() [2/4]

virtual MooseMesh & DisplacedProblem::mesh ( )

inlineoverridevirtual

Implements SubProblem.

Definition at line 49 of file DisplacedProblem.h.

49{ return _mesh; }

Referenced by SidesetAroundSubdomainUpdater::finalize(), and mesh().

◆ mesh() [3/4]

const MooseMesh & DisplacedProblem::mesh ( bool libmesh_dbg_varuse_displaced ) const

inlineoverride

Definition at line 51 of file DisplacedProblem.h.

  {
    mooseAssert(use_displaced, "An undisplaced mesh was queried from the displaced problem");
    return mesh();
  }

◆ mesh() [4/4]

virtual const MooseMesh & SubProblem::mesh ( bool use_displaced ) const

pure virtualinherited

Implemented in FEProblemBase.

◆ meshChanged()

void DisplacedProblem::meshChanged	(	bool	contract_mesh,
		bool	clean_refinement_flags
	)

Definition at line 1131 of file DisplacedProblem.C.

{
  // The mesh changed. The displaced equations system object only holds Systems, so calling
  // EquationSystems::reinit only prolongs/restricts the solution vectors, which is something that
  // needs to happen for every step of mesh adaptivity.
  _eq.reinit();
  if (contract_mesh)
    // Once vectors are restricted, we can delete children of coarsened elements
    _mesh.getMesh().contract();
  if (clean_refinement_flags)
  {
    // Finally clean refinement flags so that if someone tries to project vectors again without
    // an intervening mesh refinement to clean flags they won't run into trouble
    MeshRefinement refinement(_mesh.getMesh());
    refinement.clean_refinement_flags();
  }
 
  // Since the mesh has changed, we need to make sure that we update any of our
  // MOOSE-system specific data.
  for (auto & nl : _displaced_solver_systems)
    nl->reinit();
  _displaced_aux->reinit();
 
  // We've performed some mesh adaptivity. We need to
  // clear any quadrature nodes such that when we build the boundary node lists in
  // MooseMesh::meshChanged we don't have any extraneous extra boundary nodes lying around
  _mesh.clearQuadratureNodes();
 
  _mesh.meshChanged();
 
  // Before performing mesh adaptivity we un-displaced the mesh. We need to re-displace the mesh and
  // then reinitialize GeometricSearchData such that we have all the correct geometric information
  // for the changed mesh
  updateMesh(/*mesh_changing=*/true);
}

◆ 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(), 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)...);
  }

◆ mooseDocumentedError()

template<typename... Args>

void MooseBase::mooseDocumentedError	(	const std::string &	repo_name,
		const unsigned int	issue_num,
		Args &&...	args
	)		const

inlineinherited

Definition at line 277 of file MooseBase.h.

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

Referenced by ManifoldSubdomainGenerator::ManifoldSubdomainGenerator().

◆ mooseError()

template<typename... Args>

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

inlineinherited

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

Definition at line 271 of file MooseBase.h.

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

◆ mooseErrorNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 290 of file MooseBase.h.

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

◆ mooseInfo()

template<typename... Args>

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

inlineinherited

Definition at line 334 of file MooseBase.h.

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

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

◆ mooseWarning() [1/2]

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

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

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

◆ 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(), MFEMRefinementMarker::initialSetup(), MaterialBase::initStatefulProperties(), IterationAdaptiveDT::limitDTToPostprocessorValue(), NewmarkBeta::NewmarkBeta(), Output::Output(), MaterialOutputAction::outputHelper(), Executioner::problem(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), MooseMesh::setCoordSystem(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

◆ mooseWarningNonPrefixed() [1/2]

template<typename... Args>

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

inlineinherited

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

Definition at line 308 of file MooseBase.h.

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

◆ mooseWarningNonPrefixed() [2/2]

template<typename... Args>

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

inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

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

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

◆ needFV()

void DisplacedProblem::needFV ( )

overridevirtual

marks this problem as including/needing finite volume functionality.

Implements SubProblem.

Definition at line 1386 of file DisplacedProblem.C.

{
  _mproblem.needFV();
}

◆ nlConverged()

bool SubProblem::nlConverged ( const unsigned int nl_sys_num )

virtualinherited

Returns: whether the given nonlinear system nl_sys_num is converged.

Definition at line 717 of file SubProblem.C.

{
  mooseAssert(nl_sys_num < numNonlinearSystems(),
              "The nonlinear system number is higher than the number of systems we have!");
  return solverSystemConverged(nl_sys_num);
}

◆ nLinearIterations()

unsigned int SubProblem::nLinearIterations ( const unsigned int nl_sys_num ) const

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 767 of file SubProblem.C.

{
  return 0;
}

Referenced by IterationInfo::execute(), and NumLinearIterations::getValue().

◆ nlSysNum()

unsigned int DisplacedProblem::nlSysNum ( const NonlinearSystemName & nl_sys_name ) const

overridevirtual

Returns: the nonlinear system number corresponding to the provided nl_sys_name

Implements SubProblem.

Definition at line 1404 of file DisplacedProblem.C.

{
  return _mproblem.nlSysNum(nl_sys_name);
}

◆ nNonlinearIterations()

unsigned int SubProblem::nNonlinearIterations ( const unsigned int nl_sys_num ) const

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 761 of file SubProblem.C.

{
  return 0;
}

Referenced by IterationInfo::execute(), and NumNonlinearIterations::finalize().

◆ nonlocalCouplingMatrix()

const libMesh::CouplingMatrix & DisplacedProblem::nonlocalCouplingMatrix ( const unsigned i ) const

overridevirtual

Returns: the nonlocal coupling matrix for the i'th nonlinear system

Implements SubProblem.

Definition at line 1422 of file DisplacedProblem.C.

{
  return _mproblem.nonlocalCouplingMatrix(i);
}

◆ numLinearSystems()

std::size_t DisplacedProblem::numLinearSystems ( ) const

overridevirtual

Returns: the number of linear systems in the problem

Implements SubProblem.

Definition at line 1356 of file DisplacedProblem.C.

{
  return _mproblem.numLinearSystems();
}

◆ numMatrixTags()

unsigned int DisplacedProblem::numMatrixTags ( ) const

overridevirtual

The total number of tags.

Reimplemented from SubProblem.

Definition at line 471 of file DisplacedProblem.C.

{
  return _mproblem.numMatrixTags();
}

◆ numNonlinearSystems()

std::size_t DisplacedProblem::numNonlinearSystems ( ) const

overridevirtual

Returns: the number of nonlinear systems in the problem

Implements SubProblem.

Definition at line 1350 of file DisplacedProblem.C.

{
  return _mproblem.numNonlinearSystems();
}

◆ numSolverSystems()

std::size_t DisplacedProblem::numSolverSystems ( ) const

overridevirtual

Returns: the number of solver systems in the problem

Implements SubProblem.

Definition at line 1362 of file DisplacedProblem.C.

{
  return _mproblem.numSolverSystems();
}

◆ numVectorTags()

unsigned int DisplacedProblem::numVectorTags ( const Moose::VectorTagType type = Moose::VECTOR_TAG_ANY ) const

overridevirtual

The total number of tags, which can be limited to the tag type.

Reimplemented from SubProblem.

Definition at line 423 of file DisplacedProblem.C.

{
  return _mproblem.numVectorTags(type);
}

◆ onTimestepBegin()

void DisplacedProblem::onTimestepBegin ( )

overridevirtual

Implements SubProblem.

Definition at line 1204 of file DisplacedProblem.C.

1205{

1206}

◆ onTimestepEnd()

void DisplacedProblem::onTimestepEnd ( )

overridevirtual

Implements SubProblem.

Definition at line 1209 of file DisplacedProblem.C.

1210{

1211}

◆ operator=()

DisplacedProblem & DisplacedProblem::operator= ( DisplacedProblem && )

delete

◆ paramError()

template<typename... Args>

void MooseBase::paramError	(	const std::string &	param,
		Args...	args
	)		const

inherited

Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseError - only printing a message using the given args.

Definition at line 457 of file MooseBase.h.

{
  _pars.paramError(param, std::forward<Args>(args)...);
}

◆ parameters()

const InputParameters & MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 131 of file MooseBase.h.

131{ return _pars; }

◆ paramInfo()

template<typename... Args>

void MooseBase::paramInfo	(	const std::string &	param,
		Args...	args
	)		const

inherited

Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseInfo - only printing a message using the given args.

Definition at line 471 of file MooseBase.h.

{
  mooseInfo(_pars.paramMessage(param, std::forward<Args>(args)...));
}

Referenced by GridPartitioner::_do_partition(), ComboMarker::ComboMarker(), Control::Control(), 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(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), PlaneIDMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), ReferenceResidualConvergence::initialSetup(), FullSolveMultiApp::initialSetup(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), PNGOutput::PNGOutput(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

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

◆ prepare() [1/2]

void DisplacedProblem::prepare	(	const Elem *	elem,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 617 of file DisplacedProblem.C.

{
  for (const auto nl_sys_num : index_range(_displaced_solver_systems))
  {
    _assembly[tid][nl_sys_num]->reinit(elem);
    _displaced_solver_systems[nl_sys_num]->prepare(tid);
    // This method is called outside of residual/Jacobian callbacks during initial condition
    // evaluation
    if (!_mproblem.hasJacobian() || !_mproblem.constJacobian())
      _assembly[tid][nl_sys_num]->prepareJacobianBlock();
    _assembly[tid][nl_sys_num]->prepareResidual();
  }
 
  _displaced_aux->prepare(tid);
}

◆ prepare() [2/2]

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

overridevirtual

Implements SubProblem.

Definition at line 648 of file DisplacedProblem.C.

{
  for (const auto nl_sys_num : index_range(_displaced_solver_systems))
  {
    _assembly[tid][nl_sys_num]->reinit(elem);
    _displaced_solver_systems[nl_sys_num]->prepare(tid);
  }
  _displaced_aux->prepare(tid);
  _assembly[tid][currentNlSysNum()]->prepareBlock(ivar, jvar, dof_indices);
}

◆ prepareAssembly()

void DisplacedProblem::prepareAssembly ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 690 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->prepare();
}

◆ prepareAssemblyNeighbor()

void DisplacedProblem::prepareAssemblyNeighbor ( const THREAD_ID tid )

virtual

Definition at line 696 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->prepareNeighbor();
}

Referenced by reinitNeighborPhys(), and reinitNeighborPhys().

◆ prepareBlockNonlocal()

void DisplacedProblem::prepareBlockNonlocal	(	unsigned int	ivar,
		unsigned int	jvar,
		const std::vector< dof_id_type > &	idof_indices,
		const std::vector< dof_id_type > &	jdof_indices,
		const THREAD_ID	tid
	)

virtual

Definition at line 680 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->prepareBlockNonlocal(ivar, jvar, idof_indices, jdof_indices);
}

◆ prepareFace()

void DisplacedProblem::prepareFace	(	const Elem *	elem,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 640 of file DisplacedProblem.C.

{
  for (auto & nl : _displaced_solver_systems)
    nl->prepareFace(tid, true);
  _displaced_aux->prepareFace(tid, false);
}

◆ prepareFaceShapes()

void DisplacedProblem::prepareFaceShapes	(	unsigned int	var,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 1111 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->copyFaceShapes(var);
}

◆ prepareNeighborShapes()

void DisplacedProblem::prepareNeighborShapes	(	unsigned int	var,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 1117 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->copyNeighborShapes(var);
}

◆ prepareNonlocal()

void DisplacedProblem::prepareNonlocal ( const THREAD_ID tid )

virtual

Definition at line 634 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->prepareNonlocal();
}

◆ preparePRefinement()

void SubProblem::preparePRefinement ( )

inherited

Prepare DofMap and Assembly classes with our p-refinement information.

Definition at line 1337 of file SubProblem.C.

{
  std::unordered_set<FEFamily> disable_families;
  for (const auto & [family, flag] : _family_for_p_refinement)
    if (flag)
      disable_families.insert(family);
 
  for (const auto tid : make_range(libMesh::n_threads()))
    for (const auto s : make_range(numNonlinearSystems()))
      assembly(tid, s).havePRefinement(disable_families);
 
  auto & eq = es();
  for (const auto family : disable_families)
    for (const auto i : make_range(eq.n_systems()))
    {
      auto & system = eq.get_system(i);
      auto & dof_map = system.get_dof_map();
      for (const auto vg : make_range(system.n_variable_groups()))
      {
        const auto & var_group = system.variable_group(vg);
        if (var_group.type().family == family)
          dof_map.should_p_refine(vg, false);
      }
    }
 
  _have_p_refinement = true;
}

Referenced by FEProblemBase::init().

◆ prepareShapes()

void DisplacedProblem::prepareShapes	(	unsigned int	var,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 1105 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->copyShapes(var);
}

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

◆ refMesh()

MooseMesh & DisplacedProblem::refMesh ( )

Definition at line 1186 of file DisplacedProblem.C.

{
  return _ref_mesh;
}

Referenced by updateMesh().

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

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

◆ reinitDirac()

bool DisplacedProblem::reinitDirac	(	const Elem *	elem,
		const THREAD_ID	tid
	)

overridevirtual

Returns true if the Problem has Dirac kernels it needs to compute on elem.

Implements SubProblem.

Definition at line 702 of file DisplacedProblem.C.

{
  std::vector<Point> & points = _dirac_kernel_info.getPoints()[elem].first;
 
  unsigned int n_points = points.size();
 
  if (n_points)
  {
    for (const auto nl_sys_num : index_range(_displaced_solver_systems))
    {
      _assembly[tid][nl_sys_num]->reinitAtPhysical(elem, points);
      _displaced_solver_systems[nl_sys_num]->prepare(tid);
    }
    _displaced_aux->prepare(tid);
 
    reinitElem(elem, tid);
  }
 
  _assembly[tid][currentNlSysNum()]->prepare();
 
  return n_points > 0;
}

◆ reinitElem()

void DisplacedProblem::reinitElem	(	const Elem *	elem,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 726 of file DisplacedProblem.C.

{
  for (auto & nl : _displaced_solver_systems)
    nl->reinitElem(elem, tid);
  _displaced_aux->reinitElem(elem, tid);
}

Referenced by reinitDirac(), and reinitElemPhys().

◆ reinitElemFace()

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

overridevirtual

Implements SubProblem.

Definition at line 753 of file DisplacedProblem.C.

{
  for (const auto nl_sys_num : index_range(_displaced_solver_systems))
  {
    _assembly[tid][nl_sys_num]->reinit(elem, side);
    _displaced_solver_systems[nl_sys_num]->reinitElemFace(elem, side, tid);
  }
  _displaced_aux->reinitElemFace(elem, side, tid);
}

◆ reinitElemFaceRef()

void SubProblem::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`
	)

virtualinherited

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

Definition at line 883 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
  {
    // - Set our _current_elem for proper dof index getting in the moose variables
    // - Reinitialize all of our FE objects so we have current phi, dphi, etc. data
    // Note that our number of shape functions will reflect the number of shapes associated with the
    // interior element while the number of quadrature points will be determined by the passed pts
    // parameter (which presumably will have a number of pts reflective of a facial quadrature rule)
    assembly(tid, nl_sys_num).reinitElemFaceRef(elem, side, tolerance, pts, weights);
 
    auto & nl = systemBaseNonlinear(nl_sys_num);
 
    // Actually get the dof indices in the moose variables
    nl.prepare(tid);
 
    // Let's finally compute our variable values!
    nl.reinitElemFace(elem, side, tid);
  }
 
  // do same for aux as for nl
  systemBaseAuxiliary().prepare(tid);
  systemBaseAuxiliary().reinitElemFace(elem, side, tid);
 
  // With the dof indices set in the moose variables, now let's properly size
  // our local residuals/Jacobians
  auto & current_assembly = assembly(tid, currentNlSysNum());
  if (currentlyComputingJacobian() || currentlyComputingResidualAndJacobian())
    current_assembly.prepareJacobianBlock();
  if (!currentlyComputingJacobian())
    current_assembly.prepareResidual();
}

Referenced by FEProblemBase::reinitElemFaceRef().

◆ reinitElemNeighborAndLowerD()

void DisplacedProblem::reinitElemNeighborAndLowerD	(	const Elem *	elem,
		unsigned int	side,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 891 of file DisplacedProblem.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][currentNlSysNum()]->neighbor();
    auto & neighbor_side = _assembly[tid][currentNlSysNum()]->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][currentNlSysNum()]->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, &qps);
    }
  }
}

◆ reinitElemPhys()

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

overridevirtual

Implements SubProblem.

Definition at line 734 of file DisplacedProblem.C.

{
  mooseAssert(_mesh.queryElemPtr(elem->id()) == elem,
              "Are you calling this method with a undisplaced mesh element?");
 
  for (const auto nl_sys_num : index_range(_displaced_solver_systems))
  {
    _assembly[tid][nl_sys_num]->reinitAtPhysical(elem, phys_points_in_elem);
    _displaced_solver_systems[nl_sys_num]->prepare(tid);
    _assembly[tid][nl_sys_num]->prepare();
  }
  _displaced_aux->prepare(tid);
 
  reinitElem(elem, tid);
}

◆ reinitFVFace()

void SubProblem::reinitFVFace	(	const THREAD_ID	tid,
		const FaceInfo &	fi
	)

inherited

reinitialize the finite volume assembly data for the provided face and thread

Definition at line 1289 of file SubProblem.C.

{
  for (const auto nl : make_range(numNonlinearSystems()))
    assembly(tid, nl).reinitFVFace(fi);
}

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

{
  geomSearchData().reinit();
}

◆ reinitLowerDElem()

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

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 958 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
  {
    // - Set our _current_lower_d_elem for proper dof index getting in the moose variables
    // - Reinitialize all of our lower-d FE objects so we have current phi, dphi, etc. data
    assembly(tid, nl_sys_num).reinitLowerDElem(elem, pts, weights);
 
    auto & nl = systemBaseNonlinear(nl_sys_num);
 
    // Actually get the dof indices in the moose variables
    nl.prepareLowerD(tid);
 
    // With the dof indices set in the moose variables, now let's properly size
    // our local residuals/Jacobians
    assembly(tid, nl_sys_num).prepareLowerD();
 
    // Let's finally compute our variable values!
    nl.reinitLowerD(tid);
  }
 
  // do same for aux as for nl
  systemBaseAuxiliary().prepareLowerD(tid);
  systemBaseAuxiliary().reinitLowerD(tid);
}

Referenced by Moose::Mortar::loopOverMortarSegments(), reinitElemNeighborAndLowerD(), and FEProblemBase::reinitLowerDElem().

◆ reinitMortarElem()

void SubProblem::reinitMortarElem	(	const Elem *	elem,
		const THREAD_ID	tid = `0`
	)

inherited

Reinit a mortar element to obtain a valid JxW.

Definition at line 995 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    assembly(tid, nl_sys_num).reinitMortarElem(elem);
}

Referenced by Moose::Mortar::loopOverMortarSegments().

◆ reinitNeighbor() [1/2]

void DisplacedProblem::reinitNeighbor	(	const Elem *	elem,
		unsigned int	side,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 802 of file DisplacedProblem.C.

{
  reinitNeighbor(elem, side, tid, nullptr);
}

Referenced by reinitElemNeighborAndLowerD(), and reinitNeighbor().

◆ reinitNeighbor() [2/2]

void DisplacedProblem::reinitNeighbor	(	const Elem *	elem,
		unsigned int	side,
		const THREAD_ID	tid,
		const std::vector< Point > *	neighbor_reference_points
	)

reinitialize neighbor routine

Parameters

elem	The element driving the reinit (note that this is not the neighbor)
side	The side, e.g. face, of the `elem` that we want to reinit
tid	The thread for which we are reiniting
neighbor_reference_points	Specify the referrence points for the neighbor element. Useful if the element and neighbor faces are not coincident

Definition at line 808 of file DisplacedProblem.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 nl_sys_num : index_range(_displaced_solver_systems))
  {
    _assembly[tid][nl_sys_num]->reinitElemAndNeighbor(
        elem, side, neighbor, neighbor_side, neighbor_reference_points);
    _displaced_solver_systems[nl_sys_num]->prepareNeighbor(tid);
    // Called during stateful material property evaluation outside of solve
    _assembly[tid][nl_sys_num]->prepareNeighbor();
  }
  _displaced_aux->prepareNeighbor(tid);
 
  for (auto & nl : _displaced_solver_systems)
  {
    nl->reinitElemFace(elem, side, tid);
    nl->reinitNeighborFace(neighbor, neighbor_side, tid);
  }
  _displaced_aux->reinitElemFace(elem, side, tid);
  _displaced_aux->reinitNeighborFace(neighbor, neighbor_side, tid);
}

◆ reinitNeighborFaceRef()

void SubProblem::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`
	)

virtualinherited

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

Definition at line 922 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
  {
    // - Set our _current_neighbor_elem for proper dof index getting in the moose variables
    // - Reinitialize all of our FE objects so we have current phi, dphi, etc. data
    // Note that our number of shape functions will reflect the number of shapes associated with the
    // interior element while the number of quadrature points will be determined by the passed pts
    // parameter (which presumably will have a number of pts reflective of a facial quadrature rule)
    assembly(tid, nl_sys_num)
        .reinitNeighborFaceRef(neighbor_elem, neighbor_side, tolerance, pts, weights);
 
    auto & nl = systemBaseNonlinear(nl_sys_num);
 
    // Actually get the dof indices in the moose variables
    nl.prepareNeighbor(tid);
 
    // Let's finally compute our variable values!
    nl.reinitNeighborFace(neighbor_elem, neighbor_side, tid);
  }
 
  // do same for aux as for nl
  systemBaseAuxiliary().prepareNeighbor(tid);
  systemBaseAuxiliary().reinitNeighborFace(neighbor_elem, neighbor_side, tid);
 
  // With the dof indices set in the moose variables, now let's properly size
  // our local residuals/Jacobians
  assembly(tid, currentNlSysNum()).prepareNeighbor();
}

Referenced by FEProblemBase::reinitNeighborFaceRef().

◆ reinitNeighborLowerDElem()

void SubProblem::reinitNeighborLowerDElem	(	const Elem *	elem,
		const THREAD_ID	tid = `0`
	)

inherited

reinitialize a neighboring lower dimensional element

Definition at line 988 of file SubProblem.C.

{
  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 DisplacedProblem::reinitNeighborPhys	(	const Elem *	neighbor,
		const std::vector< Point > &	physical_points,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 865 of file DisplacedProblem.C.

{
  mooseAssert(_mesh.queryElemPtr(neighbor->id()) == neighbor,
              "Are you calling this method with a undisplaced mesh element?");
 
  for (const auto nl_sys_num : index_range(_displaced_solver_systems))
  {
    // Reinit shape functions
    _assembly[tid][nl_sys_num]->reinitNeighborAtPhysical(neighbor, physical_points);
 
    // Set the neighbor dof indices
    _displaced_solver_systems[nl_sys_num]->prepareNeighbor(tid);
  }
  _displaced_aux->prepareNeighbor(tid);
 
  prepareAssemblyNeighbor(tid);
 
  // Compute values at the points
  for (auto & nl : _displaced_solver_systems)
    nl->reinitNeighbor(neighbor, tid);
  _displaced_aux->reinitNeighbor(neighbor, tid);
}

◆ reinitNeighborPhys() [2/2]

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

overridevirtual

Implements SubProblem.

Definition at line 838 of file DisplacedProblem.C.

{
  mooseAssert(_mesh.queryElemPtr(neighbor->id()) == neighbor,
              "Are you calling this method with a undisplaced mesh element?");
 
  for (const auto nl_sys_num : index_range(_displaced_solver_systems))
  {
    // Reinit shape functions
    _assembly[tid][nl_sys_num]->reinitNeighborAtPhysical(neighbor, neighbor_side, physical_points);
 
    // Set the neighbor dof indices
    _displaced_solver_systems[nl_sys_num]->prepareNeighbor(tid);
  }
  _displaced_aux->prepareNeighbor(tid);
 
  prepareAssemblyNeighbor(tid);
 
  // Compute values at the points
  for (auto & nl : _displaced_solver_systems)
    nl->reinitNeighborFace(neighbor, neighbor_side, tid);
  _displaced_aux->reinitNeighborFace(neighbor, neighbor_side, tid);
}

◆ reinitNode()

void DisplacedProblem::reinitNode	(	const Node *	node,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 764 of file DisplacedProblem.C.

{
  for (const auto nl_sys_num : index_range(_displaced_solver_systems))
  {
    _assembly[tid][nl_sys_num]->reinit(node);
    _displaced_solver_systems[nl_sys_num]->reinitNode(node, tid);
  }
  _displaced_aux->reinitNode(node, tid);
}

◆ reinitNodeFace()

void DisplacedProblem::reinitNodeFace	(	const Node *	node,
		BoundaryID	bnd_id,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 775 of file DisplacedProblem.C.

{
  for (const auto nl_sys_num : index_range(_displaced_solver_systems))
  {
    _assembly[tid][nl_sys_num]->reinit(node);
    _displaced_solver_systems[nl_sys_num]->reinitNodeFace(node, bnd_id, tid);
  }
  _displaced_aux->reinitNodeFace(node, bnd_id, tid);
}

◆ reinitNodes()

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

overridevirtual

Implements SubProblem.

Definition at line 786 of file DisplacedProblem.C.

{
  for (auto & nl : _displaced_solver_systems)
    nl->reinitNodes(nodes, tid);
  _displaced_aux->reinitNodes(nodes, tid);
}

◆ reinitNodesNeighbor()

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

overridevirtual

Implements SubProblem.

Definition at line 794 of file DisplacedProblem.C.

{
  for (auto & nl : _displaced_solver_systems)
    nl->reinitNodesNeighbor(nodes, tid);
  _displaced_aux->reinitNodesNeighbor(nodes, tid);
}

◆ reinitOffDiagScalars()

void DisplacedProblem::reinitOffDiagScalars ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 928 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->prepareOffDiagScalar();
}

◆ reinitScalars()

void DisplacedProblem::reinitScalars	(	const THREAD_ID	tid,
		bool	reinit_for_derivative_reordering = `false`
	)

overridevirtual

fills the VariableValue arrays for scalar variables from the solution vector

Parameters

tid	The thread id
reinit_for_derivative_reordering	A flag indicating whether we are reinitializing for the purpose of re-ordering derivative information for ADNodalBCs

Implements SubProblem.

Definition at line 919 of file DisplacedProblem.C.

{
  for (auto & nl : _displaced_solver_systems)
    nl->reinitScalars(tid, reinit_for_derivative_reordering);
  _displaced_aux->reinitScalars(tid, reinit_for_derivative_reordering);
}

◆ removeAlgebraicGhostingFunctor()

void SubProblem::removeAlgebraicGhostingFunctor ( libMesh::GhostingFunctor & algebraic_gf )

inherited

Remove an algebraic ghosting functor from this problem's DofMaps.

Definition at line 1068 of file SubProblem.C.

{
  EquationSystems & eq = es();
  const auto n_sys = eq.n_systems();
  DofMap & nl_dof_map = eq.get_system(0).get_dof_map();
 
  const bool found_in_root_sys =
      std::find(nl_dof_map.algebraic_ghosting_functors_begin(),
                nl_dof_map.algebraic_ghosting_functors_end(),
                &algebraic_gf) != nl_dof_map.algebraic_ghosting_functors_end();
 
#ifndef NDEBUG
  const bool found_in_our_map =
      _root_alg_gf_to_sys_clones.find(&algebraic_gf) != _root_alg_gf_to_sys_clones.end();
  mooseAssert(found_in_root_sys == found_in_our_map,
              "If the ghosting functor exists in the root DofMap, then we need to have a key for "
              "it in our gf to clones map");
#endif
 
  if (found_in_root_sys) // libMesh yells if we try to remove
                         // something that's not there
    nl_dof_map.remove_algebraic_ghosting_functor(algebraic_gf);
 
  auto it = _root_alg_gf_to_sys_clones.find(&algebraic_gf);
  if (it == _root_alg_gf_to_sys_clones.end())
    return;
 
  auto & clones_vec = it->second;
  mooseAssert((n_sys - 1) == clones_vec.size(),
              "The size of the gf clones vector doesn't match the number of systems minus one");
  if (clones_vec.empty())
  {
    mooseAssert(n_sys == 1, "The clones vector should only be empty if there is only one system");
    return;
  }
 
  for (const auto i : make_range(n_sys))
    eq.get_system(i + 1).get_dof_map().remove_algebraic_ghosting_functor(*clones_vec[i]);
 
  _root_alg_gf_to_sys_clones.erase(it->first);
}

◆ removeCouplingGhostingFunctor()

void SubProblem::removeCouplingGhostingFunctor ( libMesh::GhostingFunctor & coupling_gf )

inherited

Remove a coupling ghosting functor from this problem's DofMaps.

Definition at line 1111 of file SubProblem.C.

{
  EquationSystems & eq = es();
  const auto num_nl_sys = numNonlinearSystems();
  if (!num_nl_sys)
    return;
 
  DofMap & nl_dof_map = eq.get_system(0).get_dof_map();
  const bool found_in_root_sys = std::find(nl_dof_map.coupling_functors_begin(),
                                           nl_dof_map.coupling_functors_end(),
                                           &coupling_gf) != nl_dof_map.coupling_functors_end();
 
#ifndef NDEBUG
  const bool found_in_our_map =
      _root_coupling_gf_to_sys_clones.find(&coupling_gf) != _root_coupling_gf_to_sys_clones.end();
  mooseAssert(found_in_root_sys == found_in_our_map,
              "If the ghosting functor exists in the root DofMap, then we need to have a key for "
              "it in our gf to clones map");
#endif
 
  if (found_in_root_sys) // libMesh yells if we try to remove
                         // something that's not there
    nl_dof_map.remove_coupling_functor(coupling_gf);
 
  auto it = _root_coupling_gf_to_sys_clones.find(&coupling_gf);
  if (it == _root_coupling_gf_to_sys_clones.end())
    return;
 
  auto & clones_vec = it->second;
  mooseAssert((num_nl_sys - 1) == clones_vec.size(),
              "The size of the gf clones vector doesn't match the number of systems minus one");
  if (clones_vec.empty())
  {
    mooseAssert(num_nl_sys == 1,
                "The clones vector should only be empty if there is only one nonlinear system");
    return;
  }
 
  for (const auto i : make_range(num_nl_sys))
    eq.get_system(i + 1).get_dof_map().remove_coupling_functor(*clones_vec[i]);
 
  _root_coupling_gf_to_sys_clones.erase(it->first);
}

◆ residualSetup()

void DisplacedProblem::residualSetup ( )

overridevirtual

Reimplemented from SubProblem.

Definition at line 1298 of file DisplacedProblem.C.

{
  SubProblem::residualSetup();
 
  for (auto & nl : _displaced_solver_systems)
    nl->residualSetup();
  _displaced_aux->residualSetup();
}

◆ restoreOldSolutions()

void DisplacedProblem::restoreOldSolutions ( )

virtual

Restore old solutions from the backup vectors and deallocate them.

Definition at line 218 of file DisplacedProblem.C.

{
  for (auto & displaced_nl : _displaced_solver_systems)
    displaced_nl->restoreOldSolutions();
  _displaced_aux->restoreOldSolutions();
}

◆ restrictionBoundaryCheckName()

std::string SubProblem::restrictionBoundaryCheckName ( BoundaryID check_id )

privateinherited

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

bool DisplacedProblem::safeAccessTaggedMatrices ( ) const

overridevirtual

Is it safe to access the tagged matrices.

Reimplemented from SubProblem.

Definition at line 1374 of file DisplacedProblem.C.

{
  return _mproblem.safeAccessTaggedMatrices();
}

◆ safeAccessTaggedVectors()

bool DisplacedProblem::safeAccessTaggedVectors ( ) const

overridevirtual

Is it safe to access the tagged vectors.

Reimplemented from SubProblem.

Definition at line 1380 of file DisplacedProblem.C.

{
  return _mproblem.safeAccessTaggedVectors();
}

◆ saveOldSolutions()

void DisplacedProblem::saveOldSolutions ( )

virtual

Allocate vectors and save old solutions into them.

Definition at line 210 of file DisplacedProblem.C.

{
  for (auto & displaced_nl : _displaced_solver_systems)
    displaced_nl->saveOldSolutions();
  _displaced_aux->saveOldSolutions();
}

◆ selectMatrixTagsFromSystem()

void SubProblem::selectMatrixTagsFromSystem	(	const SystemBase &	system,
		const std::map< TagName, TagID > &	input_matrix_tags,
		std::set< TagID > &	selected_tags
	)

staticinherited

Select the matrix tags which belong to a specific system.

Parameters

system	Reference to the system
input_matrix_tags	A map of matrix tags
selected_tags	A set which gets populated by the tag-ids that belong to the system

Definition at line 301 of file SubProblem.C.

{
  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 290 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 SubProblem::setActiveElementalMooseVariables	(	const std::set< MooseVariableFieldBase * > &	moose_vars,
		const THREAD_ID	tid
	)

virtualinherited

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

Definition at line 444 of file SubProblem.C.

{
  if (!moose_vars.empty())
  {
    _has_active_elemental_moose_variables[tid] = 1;
    _active_elemental_moose_variables[tid] = moose_vars;
  }
}

Referenced by FEProblemBase::setActiveElementalMooseVariables().

◆ setActiveFEVariableCoupleableMatrixTags()

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

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 364 of file SubProblem.C.

{
  _active_fe_var_coupleable_matrix_tags[tid] = mtags;
}

Referenced by FEProblemBase::setActiveFEVariableCoupleableMatrixTags().

◆ setActiveFEVariableCoupleableVectorTags()

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

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 370 of file SubProblem.C.

{
  _active_fe_var_coupleable_vector_tags[tid] = vtags;
  for (const auto sys_num : make_range(numSolverSystems()))
    systemBaseSolver(sys_num).setActiveVariableCoupleableVectorTags(vtags, tid);
  systemBaseAuxiliary().setActiveVariableCoupleableVectorTags(vtags, tid);
}

Referenced by FEProblemBase::setActiveFEVariableCoupleableVectorTags().

◆ setActiveScalarVariableCoupleableMatrixTags()

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

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 403 of file SubProblem.C.

{
  _active_sc_var_coupleable_matrix_tags[tid] = mtags;
}

Referenced by FEProblemBase::setActiveScalarVariableCoupleableMatrixTags().

◆ setActiveScalarVariableCoupleableVectorTags()

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

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 410 of file SubProblem.C.

{
  _active_sc_var_coupleable_vector_tags[tid] = vtags;
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    systemBaseNonlinear(nl_sys_num).setActiveScalarVariableCoupleableVectorTags(vtags, tid);
  systemBaseAuxiliary().setActiveScalarVariableCoupleableVectorTags(vtags, tid);
}

Referenced by FEProblemBase::setActiveScalarVariableCoupleableVectorTags().

◆ setChainControlDataOutput()

void SubProblem::setChainControlDataOutput ( bool set_output )

inlineinherited

Setter for debug chain control data output.

Definition at line 934 of file SubProblem.h.

934{ _show_chain_control_data = set_output; }

SubProblem::_show_chain_control_data

bool _show_chain_control_data

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

Definition SubProblem.h:1182

◆ setCurrentBoundaryID()

void SubProblem::setCurrentBoundaryID	(	BoundaryID	bid,
		const THREAD_ID	tid
	)

virtualinherited

sets the current boundary ID in assembly

Reimplemented in FEProblemBase.

Definition at line 790 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    assembly(tid, nl_sys_num).setCurrentBoundaryID(bid);
}

Referenced by FEProblemBase::setCurrentBoundaryID().

◆ setCurrentLowerDElem()

void SubProblem::setCurrentLowerDElem	(	const Elem *const	lower_d_elem,
		const THREAD_ID	tid
	)

virtualinherited

Set the current lower dimensional element.

This can be null

Reimplemented in FEProblemBase.

Definition at line 1385 of file SubProblem.C.

{
  for (const auto nl_sys_num : make_range(numNonlinearSystems()))
    assembly(tid, nl_sys_num).setCurrentLowerDElem(lower_d_elem);
}

Referenced by FEProblemBase::setCurrentLowerDElem().

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

  {
    _currently_computing_jacobian = currently_computing_jacobian;
  }

Referenced by FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::resetState().

◆ setCurrentlyComputingResidual()

virtual void SubProblem::setCurrentlyComputingResidual ( const bool currently_computing_residual )

inlinevirtualinherited

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

Reimplemented in FEProblemBase.

Definition at line 733 of file SubProblem.h.

  {
    _currently_computing_residual = currently_computing_residual;
  }

◆ setCurrentlyComputingResidualAndJacobian()

void SubProblem::setCurrentlyComputingResidualAndJacobian ( bool currently_computing_residual_and_jacobian )

inlineinherited

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

Definition at line 1511 of file SubProblem.h.

{
  _currently_computing_residual_and_jacobian = currently_computing_residual_and_jacobian;
}

Referenced by FEProblemBase::computeResidualAndJacobian(), and FEProblemBase::resetState().

◆ setCurrentSubdomainID()

void DisplacedProblem::setCurrentSubdomainID	(	const Elem *	elem,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 664 of file DisplacedProblem.C.

{
  SubdomainID did = elem->subdomain_id();
  for (auto & assembly : _assembly[tid])
    assembly->setCurrentSubdomainID(did);
}

◆ setFunctorOutput()

void SubProblem::setFunctorOutput ( bool set_output )

inlineinherited

Setter for debug functor output.

Definition at line 932 of file SubProblem.h.

932{ _show_functors = set_output; }

SubProblem::_show_functors

bool _show_functors

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

Definition SubProblem.h:1179

◆ setNeighborSubdomainID()

void DisplacedProblem::setNeighborSubdomainID	(	const Elem *	elem,
		unsigned int	side,
		const THREAD_ID	tid
	)

overridevirtual

Implements SubProblem.

Definition at line 672 of file DisplacedProblem.C.

{
  SubdomainID did = elem->neighbor_ptr(side)->subdomain_id();
  for (auto & assembly : _assembly[tid])
    assembly->setCurrentNeighborSubdomainID(did);
}

Referenced by reinitNeighbor().

◆ setResidual() [1/2]

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

pure virtualinherited

◆ setResidual() [2/2]

void DisplacedProblem::setResidual	(	NumericVector< Number > &	residual,
		const THREAD_ID	tid
	)

overridevirtual

Definition at line 1004 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->setResidual(
      residual,
      Assembly::GlobalDataKey{},
      getVectorTag(_displaced_solver_systems[currentNlSysNum()]->residualVectorTag()));
}

◆ setResidualNeighbor() [1/2]

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

pure virtualinherited

◆ setResidualNeighbor() [2/2]

void DisplacedProblem::setResidualNeighbor	(	NumericVector< Number > &	residual,
		const THREAD_ID	tid
	)

overridevirtual

Definition at line 1013 of file DisplacedProblem.C.

{
  _assembly[tid][currentNlSysNum()]->setResidualNeighbor(
      residual,
      Assembly::GlobalDataKey{},
      getVectorTag(_displaced_solver_systems[currentNlSysNum()]->residualVectorTag()));
}

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

◆ solverSys()

DisplacedSystem & DisplacedProblem::solverSys ( const unsigned int sys_num )

inline

Definition at line 480 of file DisplacedProblem.h.

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

◆ solverSysNum()

unsigned int DisplacedProblem::solverSysNum ( const SolverSystemName & solver_sys_name ) const

overridevirtual

Returns: the solver system number corresponding to the provided solver_sys_name

Implements SubProblem.

Definition at line 1416 of file DisplacedProblem.C.

{
  return _mproblem.solverSysNum(sys_name);
}

◆ solverSystemConverged()

bool DisplacedProblem::solverSystemConverged ( const unsigned int sys_num )

overridevirtual

Returns: whether the given solver system sys_num is converged

Reimplemented from SubProblem.

Definition at line 1192 of file DisplacedProblem.C.

{
  return _mproblem.converged(sys_num);
}

◆ storeBoundaryDelayedCheckMatProp()

void SubProblem::storeBoundaryDelayedCheckMatProp	(	const std::string &	requestor,
		BoundaryID	boundary_id,
		const std::string &	name
	)

virtualinherited

Adds to a map based on boundary ids of material properties to validate.

Parameters

requestor	The MOOSE object name requesting the material property
boundary_id	The block id for the MaterialProperty
name	The name of the property

Definition at line 616 of file SubProblem.C.

{
  _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 590 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 602 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 608 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 584 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 596 of file SubProblem.C.

{
  _zero_block_material_props[block_id].insert(name);
}

Referenced by MaterialBase::storeSubdomainZeroMatProp().

◆ syncAuxSolution()

void DisplacedProblem::syncAuxSolution ( const NumericVector< Number > & aux_soln )

Copy the provided solution into the displaced auxiliary system.

Definition at line 226 of file DisplacedProblem.C.

{
  (*_displaced_aux->sys().solution) = aux_soln;
  _displaced_aux->update();
}

Referenced by syncSolutions(), and syncSolutions().

◆ syncSolutions() [1/2]

void DisplacedProblem::syncSolutions ( )

Copy the solutions on the undisplaced systems to the displaced systems.

Definition at line 233 of file DisplacedProblem.C.

{
  TIME_SECTION("syncSolutions", 5, "Syncing Displaced Solutions");
 
  for (const auto nl_sys_num : index_range(_displaced_solver_systems))
  {
    auto & displaced_nl = _displaced_solver_systems[nl_sys_num];
    mooseAssert(nl_sys_num == displaced_nl->number(),
                "We should have designed things such that the nl system numbers make their system "
                "numbering in the EquationSystems object");
    (*displaced_nl->sys().solution) =
        *_mproblem.getNonlinearSystemBase(displaced_nl->number()).currentSolution();
    displaced_nl->update();
  }
  syncAuxSolution(*_mproblem.getAuxiliarySystem().currentSolution());
}

Referenced by updateMesh().

◆ syncSolutions() [2/2]

void DisplacedProblem::syncSolutions	(	const std::map< unsigned int, const NumericVector< Number > * > &	nl_solns,
		const NumericVector< Number > &	aux_soln
	)

Synchronize the solutions on the displaced systems to the given solutions.

The nonlinear solutions argument is a map from the nonlinear system number to the solution that we want to set that nonlinear system's solution to

Definition at line 251 of file DisplacedProblem.C.

{
  TIME_SECTION("syncSolutions", 5, "Syncing Displaced Solutions");
 
  for (const auto [nl_sys_num, nl_soln] : nl_solns)
  {
    (*_displaced_solver_systems[nl_sys_num]->sys().solution) = *nl_soln;
    _displaced_solver_systems[nl_sys_num]->update();
  }
  syncAuxSolution(aux_soln);
}

◆ systemBaseAuxiliary() [1/2]

virtual const SystemBase & DisplacedProblem::systemBaseAuxiliary ( ) const

inlineoverridevirtual

Return the auxiliary system object as a base class reference.

Implements SubProblem.

Definition at line 70 of file DisplacedProblem.h.

70{ return *_displaced_aux; }

◆ systemBaseAuxiliary() [2/2]

virtual SystemBase & DisplacedProblem::systemBaseAuxiliary ( )

inlineoverridevirtual

Implements SubProblem.

Definition at line 71 of file DisplacedProblem.h.

71{ return *_displaced_aux; }

◆ systemBaseLinear() [1/2]

const SystemBase & DisplacedProblem::systemBaseLinear ( const unsigned int sys_num ) const

inlineoverridevirtual

Return the linear system object as a base class reference given the system number.

Implements SubProblem.

Definition at line 504 of file DisplacedProblem.h.

{
  mooseError("Linear systems are not supported for displaced problems yet.");
}

◆ systemBaseLinear() [2/2]

SystemBase & DisplacedProblem::systemBaseLinear ( const unsigned int sys_num )

inlineoverridevirtual

Implements SubProblem.

Definition at line 510 of file DisplacedProblem.h.

{
  mooseError("Linear systems are not supported for displaced problems yet.");
}

◆ systemBaseNonlinear() [1/2]

const SystemBase & DisplacedProblem::systemBaseNonlinear ( const unsigned int sys_num ) const

inlineoverridevirtual

Return the nonlinear system object as a base class reference given the system number.

Implements SubProblem.

Definition at line 488 of file DisplacedProblem.h.

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

◆ systemBaseNonlinear() [2/2]

SystemBase & DisplacedProblem::systemBaseNonlinear ( const unsigned int sys_num )

inlineoverridevirtual

Implements SubProblem.

Definition at line 496 of file DisplacedProblem.h.

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

◆ systemBaseSolver() [1/2]

const SystemBase & DisplacedProblem::systemBaseSolver ( const unsigned int sys_num ) const

inlineoverridevirtual

Return the solver system object as a base class reference given the system number.

Implements SubProblem.

Definition at line 516 of file DisplacedProblem.h.

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

◆ systemBaseSolver() [2/2]

SystemBase & DisplacedProblem::systemBaseSolver ( const unsigned int sys_num )

inlineoverridevirtual

Implements SubProblem.

Definition at line 524 of file DisplacedProblem.h.

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

◆ terminateSolve()

virtual void Problem::terminateSolve ( )

inlinevirtualinherited

Allow objects to request clean termination of the solve.

Definition at line 37 of file Problem.h.

37{ _termination_requested = true; };

Referenced by Terminator::execute(), WebServerControl::execute(), and TerminateChainControl::terminate().

◆ timedSectionName()

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

protectedinherited

Returns: The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

{
  return _prefix.empty() ? "" : (_prefix + "::") + section_name;
}

Referenced by PerfGraphInterface::registerTimedSection(), and PerfGraphInterface::registerTimedSection().

◆ timestepSetup()

void DisplacedProblem::timestepSetup ( )

overridevirtual

Reimplemented from SubProblem.

Definition at line 1278 of file DisplacedProblem.C.

{
  SubProblem::timestepSetup();
 
  for (auto & nl : _displaced_solver_systems)
    nl->timestepSetup();
  _displaced_aux->timestepSetup();
}

◆ type()

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

inlineinherited

Get the type of this class.

Returns: the name of the type of this class

Definition at line 93 of file MooseBase.h.

  {
    mooseAssert(_type.size(), "Empty type");
    return _type;
  }

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

Get the class's combined type and name; useful in error handling.

Returns: The type and name of this class in the form '<type()> "<name()>"'.

Definition at line 57 of file MooseBase.C.

{
  return type() + std::string(" \"") + name() + std::string("\"");
}

Referenced by MaterialPropertyStorage::addProperty(), FEProblemBase::checkUserObjectNameCollision(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< T >::finalize(), ReporterData::getReporterInfo(), MFEMSamplerBase::initialSetup(), MFEMVariableSamplerBase::initialSetup(), WebServerControl::outputMessage(), and Action::timedAct().

◆ undisplaceMesh()

void DisplacedProblem::undisplaceMesh ( )

Resets the displaced mesh to the reference mesh.

Required when refining the DisplacedMesh.

Definition at line 1214 of file DisplacedProblem.C.

{
  // If undisplaceMesh() is called during initial adaptivity, it is
  // not valid to call _mesh.getActiveSemiLocalNodeRange() since it is
  // not set up yet.  So we are creating the Range by hand.
  //
  // We must undisplace *all* our nodes to the _ref_mesh
  // configuration, not just the local ones, since the partitioners
  // require this.  We are using the GRAIN_SIZE=1 from MooseMesh.C,
  // not sure how this value was decided upon.
  //
  // (DRG: The grainsize parameter is ultimately passed to TBB to help
  // it choose how to split up the range.  A grainsize of 1 says "split
  // it as much as you want".  Years ago I experimentally found that it
  // didn't matter much and that using 1 was fine.)
  //
  // Note: we don't have to invalidate/update as much stuff as
  // DisplacedProblem::updateMesh() does, since this will be handled
  // by a later call to updateMesh().
  NodeRange node_range(_mesh.getMesh().nodes_begin(),
                       _mesh.getMesh().nodes_end(),
                       /*grainsize=*/1);
 
  ResetDisplacedMeshThread rdmt(_mproblem, *this);
 
  // Undisplace the mesh using threads.
  Threads::parallel_reduce(node_range, rdmt);
}

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

◆ updateGeomSearch()

void DisplacedProblem::updateGeomSearch ( GeometricSearchData::GeometricSearchType type = GeometricSearchData::ALL )

overridevirtual

update geometric search data

Implements SubProblem.

Definition at line 1123 of file DisplacedProblem.C.

{
  TIME_SECTION("updateGeometricSearch", 3, "Updating Displaced GeometricSearch");
 
  _geometric_search_data.update(type);
}

◆ updateMesh() [1/2]

void DisplacedProblem::updateMesh ( bool mesh_changing = false )

virtual

Copy the solutions on the undisplaced systems to the displaced systems and reinitialize the geometry search data and Dirac kernel information due to mesh displacement.

The parameter mesh_changing indicates whether this method is getting called because of mesh changes, e.g. due to mesh adaptivity. If mesh_changing we need to renitialize the GeometricSearchData instead of simply update. Reinitialization operations are a super-set of update operations. Reinitialization for example re-generates neighbor nodes in NearestNodeLocators, while update does not. Additionally we do not want to use the undisplaced mesh solution because it may be out-of-sync, whereas our displaced mesh solution should be in the correct state after getting restricted/prolonged in EquationSystems::reinit

Definition at line 266 of file DisplacedProblem.C.

{
  TIME_SECTION("updateMesh", 3, "Updating Displaced Mesh");
 
  // If the mesh is changing, we are probably performing adaptivity. In that case, we do *not* want
  // to use the undisplaced mesh solution because it may be out-of-sync, whereas our displaced mesh
  // solution should be in the correct state after getting restricted/prolonged in
  // EquationSystems::reinit (must have been called before this method)
  if (!mesh_changing)
    syncSolutions();
 
  for (const auto nl_sys_num : index_range(_displaced_solver_systems))
    _nl_solution[nl_sys_num] = _displaced_solver_systems[nl_sys_num]->sys().solution.get();
  _aux_solution = _displaced_aux->sys().solution.get();
 
  // If the displaced mesh has been serialized to one processor (as
  // may have occurred if it was used for Exodus output), then we need
  // the reference mesh to be also.  For that matter, did anyone
  // somehow serialize the whole mesh?  Hopefully not but let's avoid
  // causing errors if so.
  if (_mesh.getMesh().is_serial() && !this->refMesh().getMesh().is_serial())
    this->refMesh().getMesh().allgather();
 
  if (_mesh.getMesh().is_serial_on_zero() && !this->refMesh().getMesh().is_serial_on_zero())
    this->refMesh().getMesh().gather_to_zero();
 
  UpdateDisplacedMeshThread udmt(_mproblem, *this);
 
  // We displace all nodes, not just semilocal nodes, because
  // parallel-inconsistent mesh geometry makes libMesh cry.
  NodeRange node_range(_mesh.getMesh().nodes_begin(),
                       _mesh.getMesh().nodes_end(),
                       /*grainsize=*/1);
 
  Threads::parallel_reduce(node_range, udmt);
  // Displacement of the mesh has invalidated the point locator data (e.g. bounding boxes)
  _mesh.getMesh().clear_point_locator();
 
  // The mesh has changed. Face information normals, areas, etc. must be re-calculated
  if (haveFV())
    _mesh.setupFiniteVolumeMeshData();
 
  // Update the geometric searches that depend on the displaced mesh. This call can end up running
  // NearestNodeThread::operator() which has a throw inside of it. We need to catch it and make sure
  // it's propagated to all processes before updating the point locator because the latter requires
  // communication
  try
  {
    // We may need to re-run geometric operations like SecondaryNeighborhoodTread if, for instance,
    // we have performed mesh adaptivity
    if (mesh_changing)
      _geometric_search_data.reinit();
    else
      _geometric_search_data.update();
  }
  catch (MooseException & e)
  {
    _mproblem.setException(e.what());
  }
 
  if (udmt.hasDisplacement())
    _mproblem.meshDisplaced();
 
  // The below call will throw an exception on all processes if any of our processes had an
  // exception above. This exception will be caught higher up the call stack and the error message
  // will be printed there
  _mproblem.checkExceptionAndStopSolve(/*print_message=*/false);
 
  // Since the Mesh changed, update the PointLocator object used by DiracKernels.
  _dirac_kernel_info.updatePointLocator(_mesh);
}

Referenced by meshChanged().

◆ updateMesh() [2/2]

virtual void DisplacedProblem::updateMesh	(	const std::map< unsigned int, const NumericVector< Number > * > &	nl_soln,
		const NumericVector< Number > &	aux_soln
	)

virtual

Synchronize the solutions on the displaced systems to the given solutions and reinitialize the geometry search data and Dirac kernel information due to mesh displacement.

◆ validParams()

InputParameters DisplacedProblem::validParams ( )

static

Definition at line 34 of file DisplacedProblem.C.

{
  InputParameters params = SubProblem::validParams();
  params.addClassDescription(
      "A Problem object for providing access to the displaced finite element "
      "mesh and associated variables.");
  params.addPrivateParam<MooseMesh *>("mesh");
  params.addPrivateParam<std::vector<std::string>>("displacements", {});
  return params;
}

◆ vectorTagExists() [1/2]

bool DisplacedProblem::vectorTagExists ( const TagID tag_id ) const

overridevirtual

Check to see if a particular Tag exists.

Reimplemented from SubProblem.

Definition at line 411 of file DisplacedProblem.C.

{
  return _mproblem.vectorTagExists(tag_id);
}

◆ vectorTagExists() [2/2]

bool DisplacedProblem::vectorTagExists ( const TagName & tag_name ) const

overridevirtual

Check to see if a particular Tag exists by using Tag name.

Reimplemented from SubProblem.

Definition at line 417 of file DisplacedProblem.C.

{
  return _mproblem.vectorTagExists(tag_name);
}

◆ vectorTagName()

TagName DisplacedProblem::vectorTagName ( const TagID tag ) const

overridevirtual

Retrieve the name associated with a TagID.

Reimplemented from SubProblem.

Definition at line 405 of file DisplacedProblem.C.

{
  return _mproblem.vectorTagName(tag_id);
}

◆ vectorTagNotZeroed()

bool SubProblem::vectorTagNotZeroed ( const TagID tag ) const

inherited

Checks if a vector tag is in the list of vectors that will not be zeroed when other tagged vectors are.

Parameters

tag	the TagID of the vector that is currently being checked

Returns: false if the tag is not within the set of vectors that are intended to not be zero or if the set is empty. returns true otherwise

Definition at line 156 of file SubProblem.C.

{
  return _not_zeroed_tagged_vectors.count(tag);
}

Referenced by SystemBase::zeroTaggedVector().

◆ vectorTagType()

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

overridevirtual

Reimplemented from SubProblem.

Definition at line 435 of file DisplacedProblem.C.

{
  return _mproblem.vectorTagType(tag_id);
}

◆ verifyVectorTags()

bool SubProblem::verifyVectorTags ( ) const

protectedinherited

Verify the integrity of _vector_tags and _typed_vector_tags.

Definition at line 242 of file SubProblem.C.

{
  for (TagID tag_id = 0; tag_id < _vector_tags.size(); ++tag_id)
  {
    const auto & vector_tag = _vector_tags[tag_id];
 
    if (vector_tag._id != tag_id)
      mooseError("Vector tag ", vector_tag._id, " id mismatch in _vector_tags");
    if (vector_tag._type == Moose::VECTOR_TAG_ANY)
      mooseError("Vector tag '", vector_tag._name, "' has type VECTOR_TAG_ANY");
 
    const auto search = _vector_tags_name_map.find(vector_tag._name);
    if (search == _vector_tags_name_map.end())
      mooseError("Vector tag ", vector_tag._id, " is not in _vector_tags_name_map");
    else if (search->second != tag_id)
      mooseError("Vector tag ", vector_tag._id, " has incorrect id in _vector_tags_name_map");
 
    unsigned int found_in_type = 0;
    for (TagTypeID tag_type_id = 0; tag_type_id < _typed_vector_tags[vector_tag._type].size();
         ++tag_type_id)
    {
      const auto & vector_tag_type = _typed_vector_tags[vector_tag._type][tag_type_id];
      if (vector_tag_type == vector_tag)
      {
        ++found_in_type;
        if (vector_tag_type._type_id != tag_type_id)
          mooseError("Type ID for Vector tag ", tag_id, " is incorrect");
      }
    }
 
    if (found_in_type == 0)
      mooseError("Vector tag ", tag_id, " not found in _typed_vector_tags");
    if (found_in_type > 1)
      mooseError("Vector tag ", tag_id, " found multiple times in _typed_vector_tags");
  }
 
  unsigned int num_typed_vector_tags = 0;
  for (const auto & typed_vector_tags : _typed_vector_tags)
    num_typed_vector_tags += typed_vector_tags.size();
  if (num_typed_vector_tags != _vector_tags.size())
    mooseError("Size mismatch between _vector_tags and _typed_vector_tags");
  if (_vector_tags_name_map.size() != _vector_tags.size())
    mooseError("Size mismatch between _vector_tags and _vector_tags_name_map");
 
  return true;
}

Referenced by SubProblem::addVectorTag(), SubProblem::getVectorTag(), SubProblem::getVectorTagID(), SubProblem::getVectorTags(), SubProblem::getVectorTags(), SubProblem::numVectorTags(), SubProblem::vectorTagExists(), SubProblem::vectorTagName(), and SubProblem::vectorTagType().

Friends And Related Symbol Documentation

◆ Restartable

friend class Restartable

friend

Definition at line 476 of file DisplacedProblem.h.

◆ UpdateDisplacedMeshThread

friend class UpdateDisplacedMeshThread

friend

Definition at line 475 of file DisplacedProblem.h.

Member Data Documentation

◆ _action_factory

ActionFactory& ParallelParamObject::_action_factory

protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

Referenced by AddActionComponentAction::act(), CreateMeshSetupActionsForComponents::act(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), CreateExecutionerAction::setupAutoPreconditioning(), and ReadExecutorParamsAction::setupAutoPreconditioning().

◆ _active_elemental_moose_variables

std::vector<std::set<MooseVariableFieldBase *> > SubProblem::_active_elemental_moose_variables

protectedinherited

This is the set of MooseVariableFieldBase that will actually get reinited by a call to reinit(elem)

Definition at line 1090 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 1096 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 1098 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 1100 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 1102 of file SubProblem.h.

Referenced by SubProblem::clearActiveScalarVariableCoupleableVectorTags(), SubProblem::getActiveScalarVariableCoupleableVectorTags(), SubProblem::setActiveScalarVariableCoupleableVectorTags(), and SubProblem::SubProblem().

◆ _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(), 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(), NEML2Assembly::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(), 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(), MFEMMesh::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(), 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(), NEML2FEInterpolation::updateDofMap(), NEML2FEInterpolation::updateGradPhi(), NEML2FEInterpolation::updateInterpolations(), FEProblemBase::updateMortarMesh(), NEML2FEInterpolation::updatePhi(), Console::write(), and FEProblemBase::~FEProblemBase().

◆ _assembly

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

protected

Definition at line 410 of file DisplacedProblem.h.

Referenced by addCachedResidualDirectly(), addJacobian(), addJacobianBlockNonlocal(), addJacobianBlockTags(), addJacobianLowerD(), addJacobianNeighbor(), addJacobianNeighborLowerD(), addJacobianNonlocal(), addResidual(), addResidualLower(), addResidualNeighbor(), assembly(), assembly(), bumpAllQRuleOrder(), bumpVolumeQRuleOrder(), cacheJacobianNonlocal(), createQRules(), DisplacedProblem(), init(), prepare(), prepare(), prepareAssembly(), prepareAssemblyNeighbor(), prepareBlockNonlocal(), prepareFaceShapes(), prepareNeighborShapes(), prepareNonlocal(), prepareShapes(), reinitDirac(), reinitElemFace(), reinitElemNeighborAndLowerD(), reinitElemPhys(), reinitNeighbor(), reinitNeighborPhys(), reinitNeighborPhys(), reinitNode(), reinitNodeFace(), reinitOffDiagScalars(), setCurrentSubdomainID(), setNeighborSubdomainID(), setResidual(), and setResidualNeighbor().

◆ _aux_solution

const NumericVector<Number>* DisplacedProblem::_aux_solution

protected

The auxiliary system solution.

Definition at line 408 of file DisplacedProblem.h.

Referenced by updateMesh().

◆ _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().

◆ _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 1117 of file SubProblem.h.

Referenced by SubProblem::computingNonlinearResid(), FEProblemBase::computingNonlinearResid(), and SubProblem::computingNonlinearResid().

◆ _console

const ConsoleStream ConsoleStreamInterface::_console

inherited

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

Definition at line 31 of file ConsoleStreamInterface.h.

◆ _consumed_material_properties

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

privateinherited

Definition at line 1203 of file SubProblem.h.

Referenced by SubProblem::addConsumedPropertyName(), and SubProblem::getConsumedPropertyMap().

◆ _currently_computing_jacobian

bool SubProblem::_currently_computing_jacobian

protectedinherited

Flag to determine whether the problem is currently computing Jacobian.

Definition at line 1111 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 1120 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 1114 of file SubProblem.h.

Referenced by SubProblem::currentlyComputingResidualAndJacobian(), and SubProblem::setCurrentlyComputingResidualAndJacobian().

◆ _default_families_without_p_refinement

const std::unordered_set< FEFamily > SubProblem::_default_families_without_p_refinement

staticprivateinherited

Initial value:

= {
    libMesh::LAGRANGE,
    libMesh::NEDELEC_ONE,
    libMesh::RAVIART_THOMAS,
    libMesh::LAGRANGE_VEC,
    libMesh::CLOUGH,
    libMesh::BERNSTEIN,
    libMesh::RATIONAL_BERNSTEIN}

The set of variable families by default disable p-refinement.

Definition at line 50 of file SubProblem.h.

{
class FunctorEnvelopeBase;
}
 

Referenced by SubProblem::markFamilyPRefinement().

◆ _default_ghosting

bool SubProblem::_default_ghosting

protectedinherited

Whether or not to use default libMesh coupling.

Definition at line 1105 of file SubProblem.h.

Referenced by SubProblem::defaultGhosting().

◆ _dirac_kernel_info

DiracKernelInfo SubProblem::_dirac_kernel_info

protectedinherited

Definition at line 1064 of file SubProblem.h.

Referenced by clearDiracInfo(), FEProblemBase::clearDiracInfo(), SubProblem::diracKernelInfo(), getDiracElements(), FEProblemBase::getDiracElements(), FEProblemBase::meshChanged(), reinitDirac(), FEProblemBase::reinitDirac(), and updateMesh().

◆ _displaced_aux

std::unique_ptr<DisplacedSystem> DisplacedProblem::_displaced_aux

protected

◆ _displaced_solver_systems

std::vector<std::unique_ptr<DisplacedSystem> > DisplacedProblem::_displaced_solver_systems

protected

Definition at line 401 of file DisplacedProblem.h.

Referenced by addCachedResidualDirectly(), addTimeIntegrator(), addVariable(), customSetup(), DisplacedProblem(), getActualFieldVariable(), getArrayVariable(), getScalarVariable(), getStandardVariable(), getVariable(), getVectorVariable(), hasScalarVariable(), hasVariable(), init(), initialSetup(), jacobianSetup(), meshChanged(), prepare(), prepare(), prepareFace(), reinitDirac(), reinitElem(), reinitElemFace(), reinitElemPhys(), reinitNeighbor(), reinitNeighborPhys(), reinitNeighborPhys(), reinitNode(), reinitNodeFace(), reinitNodes(), reinitNodesNeighbor(), reinitScalars(), residualSetup(), restoreOldSolutions(), saveOldSolutions(), setResidual(), setResidualNeighbor(), solverSys(), syncSolutions(), syncSolutions(), systemBaseNonlinear(), systemBaseNonlinear(), systemBaseSolver(), systemBaseSolver(), timestepSetup(), and updateMesh().

◆ _displacements

std::vector<std::string> DisplacedProblem::_displacements

protected

Definition at line 399 of file DisplacedProblem.h.

Referenced by getDisplacementVarNames(), and init().

◆ _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().

◆ _eq

EquationSystems DisplacedProblem::_eq

protected

Definition at line 396 of file DisplacedProblem.h.

Referenced by DisplacedProblem(), es(), getSystem(), init(), and meshChanged().

◆ _factory

Factory& SubProblem::_factory

protectedinherited

The Factory for building objects.

Definition at line 1062 of file SubProblem.h.

◆ _family_for_p_refinement

std::unordered_map<FEFamily, bool> SubProblem::_family_for_p_refinement

privateinherited

Indicate whether a family is disabled for p-refinement.

Definition at line 1223 of file SubProblem.h.

Referenced by SubProblem::markFamilyPRefinement(), and SubProblem::preparePRefinement().

◆ _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 1176 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 1172 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 1159 of file SubProblem.h.

Referenced by SubProblem::addFunctor(), SubProblem::getFunctor(), SubProblem::hasFunctor(), SubProblem::hasFunctorWithType(), SubProblem::initialSetup(), SubProblem::showFunctors(), and SubProblem::SubProblem().

◆ _geometric_search_data

GeometricSearchData DisplacedProblem::_geometric_search_data

protected

Definition at line 412 of file DisplacedProblem.h.

Referenced by geomSearchData(), updateGeomSearch(), and updateMesh().

◆ _ghosted_elems

std::set<dof_id_type> SubProblem::_ghosted_elems

protectedinherited

Elements that should have Dofs ghosted to the local processor.

Definition at line 1108 of file SubProblem.h.

Referenced by FEProblemBase::addGhostedElem(), SubProblem::ghostedElems(), FEProblemBase::meshChanged(), FEProblemBase::possiblyRebuildGeomSearchPatches(), and FEProblemBase::reinitBecauseOfGhostingOrNewGeomObjects().

◆ _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 1094 of file SubProblem.h.

Referenced by SubProblem::clearActiveElementalMooseVariables(), SubProblem::hasActiveElementalMooseVariables(), SubProblem::setActiveElementalMooseVariables(), and SubProblem::SubProblem().

◆ _have_ad_objects

bool SubProblem::_have_ad_objects

protectedinherited

AD flag indicating whether any AD objects have been added.

Definition at line 1129 of file SubProblem.h.

Referenced by SubProblem::haveADObjects(), SubProblem::haveADObjects(), haveADObjects(), and FEProblemBase::haveADObjects().

◆ _have_p_refinement

bool SubProblem::_have_p_refinement

privateinherited

Whether p-refinement has been requested at any point during the simulation.

Definition at line 1220 of file SubProblem.h.

Referenced by SubProblem::havePRefinement(), and SubProblem::preparePRefinement().

◆ _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 1067 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 1085 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 1070 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 1086 of file SubProblem.h.

Referenced by SubProblem::checkBoundaryMatProps(), and SubProblem::storeBoundaryDelayedCheckMatProp().

◆ _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 1077 of file SubProblem.h.

Referenced by SubProblem::isMatPropRequested(), and SubProblem::markMatPropRequested().

◆ _matrix_tag_id_to_tag_name

std::map<TagID, TagName> SubProblem::_matrix_tag_id_to_tag_name

protectedinherited

Reverse map.

Definition at line 1059 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 1056 of file SubProblem.h.

Referenced by SubProblem::addMatrixTag(), SubProblem::getMatrixTagID(), SubProblem::getMatrixTags(), SubProblem::matrixTagExists(), and SubProblem::numMatrixTags().

◆ _mesh

MooseMesh& DisplacedProblem::_mesh

protected

Definition at line 395 of file DisplacedProblem.h.

Referenced by DisplacedProblem(), init(), mesh(), mesh(), meshChanged(), reinitElemNeighborAndLowerD(), reinitElemPhys(), reinitNeighborPhys(), reinitNeighborPhys(), undisplaceMesh(), and updateMesh().

◆ _mproblem

FEProblemBase& DisplacedProblem::_mproblem

protected

Definition at line 394 of file DisplacedProblem.h.

Referenced by addGhostedBoundary(), addGhostedElem(), addMatrixTag(), addTimeIntegrator(), addVectorTag(), checkNonlocalCouplingRequirement(), checkResidualForNans(), computingPreSMOResidual(), computingScalingJacobian(), computingScalingResidual(), couplingMatrix(), currentLinearSysNum(), currentNlSysNum(), currentResidualVectorTags(), determineSolverSystem(), DisplacedProblem(), getLineSearch(), getMatrixTagID(), getVectorTag(), getVectorTagID(), getVectorTags(), ghostedElems(), ghostGhostedBoundaries(), hasNonlocalCoupling(), haveADObjects(), haveFV(), init(), isTransient(), linearSysNum(), matrixTagExists(), matrixTagExists(), matrixTagName(), needFV(), nlSysNum(), nonlocalCouplingMatrix(), numLinearSystems(), numMatrixTags(), numNonlinearSystems(), numSolverSystems(), numVectorTags(), prepare(), safeAccessTaggedMatrices(), safeAccessTaggedVectors(), solverSysNum(), solverSystemConverged(), syncSolutions(), undisplaceMesh(), updateMesh(), vectorTagExists(), vectorTagExists(), vectorTagName(), and vectorTagType().

◆ _name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

◆ _nl_solution

std::vector<const NumericVector<Number> *> DisplacedProblem::_nl_solution

protected

The nonlinear system solutions.

Definition at line 405 of file DisplacedProblem.h.

Referenced by DisplacedProblem(), and updateMesh().

◆ _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 1132 of file SubProblem.h.

Referenced by SubProblem::addNotZeroedVectorTag(), FEProblemBase::restoreSolutions(), and SubProblem::vectorTagNotZeroed().

◆ _parent

const ParallelParamObject& DataFileInterface::_parent

privateinherited

Definition at line 58 of file DataFileInterface.h.

Referenced by DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), and DataFileInterface::getDataFilePath().

◆ _pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 384 of file MooseBase.h.

Referenced by AddAuxKernelAction::act(), AddFVICAction::act(), AddICAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), EigenProblemSolve::initialSetup(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), 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 1162 of file SubProblem.h.

Referenced by SubProblem::addPiecewiseByBlockLambdaFunctor(), SubProblem::customSetup(), SubProblem::jacobianSetup(), SubProblem::residualSetup(), SubProblem::SubProblem(), and SubProblem::timestepSetup().

◆ _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().

◆ _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().

◆ _ref_mesh

MooseMesh& DisplacedProblem::_ref_mesh

protected

reference mesh

Definition at line 398 of file DisplacedProblem.h.

Referenced by DisplacedProblem(), DisplacedProblem::UpdateDisplacedMeshThread::init(), DisplacedProblem::UpdateDisplacedMeshThread::onNode(), and refMesh().

◆ _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 1210 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 1217 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 1123 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 1126 of file SubProblem.h.

Referenced by FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualTags(), FEProblemBase::resetState(), and SubProblem::safeAccessTaggedVectors().

◆ _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 1182 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 1179 of file SubProblem.h.

Referenced by SubProblem::initialSetup(), and SubProblem::setFunctorOutput().

◆ _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().

◆ _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().

◆ _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 1192 of file SubProblem.h.

Referenced by SubProblem::addVectorTag(), SubProblem::getVectorTags(), and SubProblem::verifyVectorTags().

◆ _var_dof_map

std::map<std::string, std::vector<dof_id_type> > SubProblem::_var_dof_map

inherited

Definition at line 682 of file SubProblem.h.

Referenced by MooseVariableBase::allDofIndices(), EigenProblem::computeJacobian(), and FEProblemBase::setNonlocalCouplingMatrix().

◆ _vector_tags

std::vector<VectorTag> SubProblem::_vector_tags

privateinherited

The declared vector tags.

Definition at line 1185 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 1195 of file SubProblem.h.

Referenced by SubProblem::addVectorTag(), SubProblem::getVectorTagID(), and SubProblem::verifyVectorTags().

◆ _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 1073 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 1074 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/problems/DisplacedProblem.h
src/problems/DisplacedProblem.C

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Member Enumeration Documentation

◆ TrueFunctorIs

Constructor & Destructor Documentation

◆ DisplacedProblem() [1/2]

◆ DisplacedProblem() [2/2]

◆ ~DisplacedProblem()

Member Function Documentation

◆ _setCLIOption()

◆ addAlgebraicGhostingFunctor()

◆ addAuxVariable()

◆ addCachedJacobian()

◆ addCachedResidual()

◆ addCachedResidualDirectly()

◆ addConsumedPropertyName()

◆ addCouplingGhostingFunctor()

◆ addFunctor()

◆ addGhostedBoundary()

◆ addGhostedElem()

◆ addJacobian()

◆ addJacobianBlockNonlocal()

◆ addJacobianBlockTags()

◆ addJacobianLowerD()

◆ addJacobianNeighbor() [1/3]

◆ addJacobianNeighbor() [2/3]

◆ addJacobianNeighbor() [3/3]

◆ addJacobianNeighborLowerD()

◆ addJacobianNonlocal()

◆ addMatrixTag()

◆ addNotZeroedVectorTag()

◆ addPiecewiseByBlockLambdaFunctor()

◆ addResidual()

◆ addResidualLower()

◆ addResidualNeighbor()

◆ addTimeIntegrator()

◆ addVariable()

◆ addVectorTag()

◆ assembly() [1/2]

◆ assembly() [2/2]

◆ automaticScaling() [1/2]

◆ automaticScaling() [2/2]

◆ auxSys()

◆ bumpAllQRuleOrder()

◆ bumpVolumeQRuleOrder()

◆ cacheJacobian()

◆ cacheJacobianNeighbor()

◆ cacheJacobianNonlocal()

◆ cacheResidual()

◆ cacheResidualNeighbor()

◆ callMooseError() [1/2]

◆ callMooseError() [2/2]

◆ checkBlockMatProps()

◆ checkBoundaryMatProps()

◆ checkNonlocalCouplingRequirement()

◆ checkResidualForNans()

◆ clearActiveElementalMooseVariables()

◆ clearActiveFEVariableCoupleableMatrixTags()

◆ clearActiveFEVariableCoupleableVectorTags()

◆ clearActiveScalarVariableCoupleableMatrixTags()

◆ clearActiveScalarVariableCoupleableVectorTags()

◆ clearAllDofIndices()

◆ clearDiracInfo()

◆ cloneAlgebraicGhostingFunctor()

◆ cloneCouplingGhostingFunctor()