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

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

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

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

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

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

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

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

void	syncAuxSolution (const NumericVector< Number > &aux_soln)
	Copy the provided solution into the displaced auxiliary system. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual bool	isTransient () const override

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

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

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

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

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

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

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

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

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

virtual void	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. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual bool	checkNonlocalCouplingRequirement () const override

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Moose::CoordinateSystemType	getCoordSystem (SubdomainID sid) const

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

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

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

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

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

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

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

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

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

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

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

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

virtual void	checkBlockMatProps ()
	Checks block material properties integrity. More...

virtual void	checkBoundaryMatProps ()
	Checks boundary material properties integrity. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual void	automaticScaling (bool automatic_scaling)
	Automatic scaling setter. More...

bool	automaticScaling () const
	Automatic scaling getter. More...

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

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

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

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

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

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

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

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

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

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

bool	doingPRefinement () const

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

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

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

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

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

const ConsoleStream &	console () const
	Return console handle. More...

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

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

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

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

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

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

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

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

MooseObjectName	uniqueName () const

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PerfGraph &	perfGraph ()
	Get the PerfGraph. More...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Protected Attributes
FEProblemBase &	_mproblem

MooseMesh &	_mesh

EquationSystems	_eq

MooseMesh &	_ref_mesh
	reference mesh More...

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

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

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

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

Factory &	_factory
	The Factory for building objects. More...

DiracKernelInfo	_dirac_kernel_info

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

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

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

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

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

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

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

std::vector< std::set< 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. More...

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

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

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

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

bool	_currently_computing_residual
	Whether the residual is being evaluated. More...

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

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

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

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

bool	_cli_option_found
	True if the CLI option is found. More...

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

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

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

MooseApp &	_app
	The MOOSE application this is associated with. More...

ActionFactory &	_action_factory
	Builds Actions. More...

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

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

const InputParameters &	_pars
	The object's parameters. More...

const Parallel::Communicator &	_communicator

MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph. More...

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


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

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

Private Member Functions
virtual std::pair< bool, unsigned int >	determineSolverSystem (const std::string &var_name, bool error_if_not_found=false) const override

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.

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

Referenced by FEProblemBase::addCachedJacobian().

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

◆ addCachedResidual()

void SubProblem::addCachedResidual ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 1305 of file SubProblem.C.

Referenced by FEProblemBase::addCachedResidual().

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

◆ 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()));
 
   // 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 736 of file SubProblem.C.

Referenced by MaterialPropertyInterface::addConsumedPropertyName().

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

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

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

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

◆ 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 1159 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 1153 of file DisplacedProblem.C.

 {
   _mproblem.addGhostedElem(elem_id);
 }

◆ addJacobian()

void DisplacedProblem::addJacobian ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 1007 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 1056 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 1043 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 1031 of file DisplacedProblem.C.

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

◆ addJacobianNeighbor() [1/2]

void DisplacedProblem::addJacobianNeighbor ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 1019 of file DisplacedProblem.C.

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

◆ addJacobianNeighbor() [2/2]

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

Implements SubProblem.

◆ addJacobianNeighborLowerD()

void DisplacedProblem::addJacobianNeighborLowerD ( const THREAD_ID tid )

overridevirtual

Implements SubProblem.

Definition at line 1025 of file DisplacedProblem.C.

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

◆ addJacobianNonlocal()

void DisplacedProblem::addJacobianNonlocal ( const THREAD_ID tid )

virtual

Definition at line 1013 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 149 of file SubProblem.C.

Referenced by FEProblemBase::createTagVectors().

 {
   _not_zeroed_tagged_vectors.insert(tag);
 }

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

Referenced by FunctorMaterial::addFunctorPropertyByBlocks().

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

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

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

overridevirtual

Implements SubProblem.

Definition at line 1317 of file DisplacedProblem.C.

Referenced by setCurrentSubdomainID(), and setNeighborSubdomainID().

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

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

overridevirtual

Implements SubProblem.

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

◆ automaticScaling() [1/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.

Definition at line 1155 of file SubProblem.C.

Referenced by MooseVariableBase::initialSetup().

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

◆ automaticScaling() [2/2]

bool SubProblem::automaticScaling ( ) const

inherited

Automatic scaling getter.

Returns: A boolean representing whether we are performing automatic scaling

Definition at line 1162 of file SubProblem.C.

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

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

◆ auxSys()

DisplacedSystem& DisplacedProblem::auxSys ( )

inline

Definition at line 59 of file DisplacedProblem.h.

59 { return *_displaced_aux; }

DisplacedProblem::_displaced_aux

std::unique_ptr< DisplacedSystem > _displaced_aux

Definition: DisplacedProblem.h:398

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

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

◆ cacheJacobian()

void SubProblem::cacheJacobian ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 1312 of file SubProblem.C.

Referenced by FEProblemBase::cacheJacobian().

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

◆ cacheJacobianNeighbor()

void SubProblem::cacheJacobianNeighbor ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 1320 of file SubProblem.C.

Referenced by FEProblemBase::cacheJacobianNeighbor().

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

◆ cacheJacobianNonlocal()

void DisplacedProblem::cacheJacobianNonlocal ( const THREAD_ID tid )

virtual

Definition at line 1037 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 1291 of file SubProblem.C.

Referenced by FEProblemBase::cacheResidual().

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

◆ cacheResidualNeighbor()

void SubProblem::cacheResidualNeighbor ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 1298 of file SubProblem.C.

Referenced by FEProblemBase::cacheResidualNeighbor().

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

◆ callMooseError() [1/2]

void MooseBase::callMooseError	(	std::string	msg,
		const bool	with_prefix,
		const hit::Node *	node = `nullptr`
	)		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

Definition at line 102 of file MooseBase.C.

Referenced by InputParameters::callMooseError(), MooseBase::mooseDocumentedError(), MooseBase::mooseError(), and MooseBase::mooseErrorNonPrefixed().

 {
   callMooseError(&_app, _pars, msg, with_prefix, node);
 }

◆ callMooseError() [2/2]

void MooseBase::callMooseError	(	MooseApp *const	app,
		const InputParameters &	params,
		std::string	msg,
		const bool	with_prefix,
		const hit::Node *	node
	)

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

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

◆ checkBlockMatProps()

void SubProblem::checkBlockMatProps ( )

virtualinherited

Checks block material properties integrity.

See also: FEProblemBase::checkProblemIntegrity

Definition at line 623 of file SubProblem.C.

Referenced by FEProblemBase::checkProblemIntegrity().

 {
   // 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());
 }

◆ checkBoundaryMatProps()

void SubProblem::checkBoundaryMatProps ( )

virtualinherited

Checks boundary material properties integrity.

See also: FEProblemBase::checkProblemIntegrity

Definition at line 665 of file SubProblem.C.

Referenced by FEProblemBase::checkProblemIntegrity().

 {
   // 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());
 }

◆ 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 or inactive nonlocal kernels or boundary conditions

Implements SubProblem.

Definition at line 1413 of file DisplacedProblem.C.

 {
   return _mproblem.checkNonlocalCouplingRequirement();
 }

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

Referenced by FEProblemBase::clearActiveElementalMooseVariables().

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

◆ clearActiveFEVariableCoupleableMatrixTags()

void SubProblem::clearActiveFEVariableCoupleableMatrixTags ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 384 of file SubProblem.C.

Referenced by FEProblemBase::clearActiveFEVariableCoupleableMatrixTags().

 {
   _active_fe_var_coupleable_matrix_tags[tid].clear();
 }

◆ clearActiveFEVariableCoupleableVectorTags()

void SubProblem::clearActiveFEVariableCoupleableVectorTags ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 378 of file SubProblem.C.

Referenced by FEProblemBase::clearActiveFEVariableCoupleableVectorTags().

 {
   _active_fe_var_coupleable_vector_tags[tid].clear();
 }

◆ clearActiveScalarVariableCoupleableMatrixTags()

void SubProblem::clearActiveScalarVariableCoupleableMatrixTags ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 425 of file SubProblem.C.

Referenced by FEProblemBase::clearActiveScalarVariableCoupleableMatrixTags().

 {
   _active_sc_var_coupleable_matrix_tags[tid].clear();
 }

◆ clearActiveScalarVariableCoupleableVectorTags()

void SubProblem::clearActiveScalarVariableCoupleableVectorTags ( const THREAD_ID tid )

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 419 of file SubProblem.C.

Referenced by FEProblemBase::clearActiveScalarVariableCoupleableVectorTags().

 {
   _active_sc_var_coupleable_vector_tags[tid].clear();
 }

◆ clearAllDofIndices()

void SubProblem::clearAllDofIndices ( )

inherited

Clear dof indices from variables in nl and aux systems.

Definition at line 1177 of file SubProblem.C.

Referenced by FEProblemBase::solve().

 {
   for (const auto nl_sys_num : make_range(numNonlinearSystems()))
     systemBaseNonlinear(nl_sys_num).clearAllDofIndices();
   systemBaseAuxiliary().clearAllDofIndices();
 }

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

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

707 { return _computing_nonlinear_residual; }

SubProblem::_computing_nonlinear_residual

bool _computing_nonlinear_residual

Whether the non-linear residual is being evaluated.

Definition: SubProblem.h:1102

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

Definition at line 712 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 1183 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 1241 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 1247 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 74 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.

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

113 { return solverSystemConverged(sys_num); }

SubProblem::solverSystemConverged

virtual bool solverSystemConverged(const unsigned int sys_num)

Definition: SubProblem.h:100

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

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

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

684 { 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:1096

◆ currentlyComputingResidual()

const bool& SubProblem::currentlyComputingResidual ( ) const

inlineinherited

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

Definition at line 720 of file SubProblem.h.

720 { return _currently_computing_residual; }

SubProblem::_currently_computing_residual

bool _currently_computing_residual

Whether the residual is being evaluated.

Definition: SubProblem.h:1105

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

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

 {
   return _currently_computing_residual_and_jacobian;
 }

◆ currentNlSysNum()

unsigned int DisplacedProblem::currentNlSysNum ( ) const

overridevirtual

Returns: the current nonlinear system number

Implements SubProblem.

Definition at line 605 of file DisplacedProblem.C.

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

 {
   return _mproblem.currentNlSysNum();
 }

◆ currentResidualVectorTags()

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

overridevirtual

Return the residual vector tags we are currently computing.

Implements SubProblem.

Definition at line 1353 of file DisplacedProblem.C.

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

 {
   return _mproblem.currentResidualVectorTags();
 }

◆ customSetup()

void DisplacedProblem::customSetup ( const ExecFlagType & exec_type )

overridevirtual

Reimplemented from SubProblem.

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

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

144 { return _default_ghosting; }

SubProblem::_default_ghosting

bool _default_ghosting

Whether or not to use default libMesh coupling.

Definition: SubProblem.h:1090

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

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

◆ diracKernelInfo()

DiracKernelInfo & SubProblem::diracKernelInfo ( )

virtualinherited

Definition at line 748 of file SubProblem.C.

 {
   return _dirac_kernel_info;
 }

◆ doingPRefinement()

bool SubProblem::doingPRefinement ( ) const

inherited

Returns: whether we're doing p-refinement

Definition at line 1361 of file SubProblem.C.

Referenced by FEProblemBase::meshChanged().

 {
   return mesh().doingPRefinement();
 }

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 39 of file MooseObject.h.

Referenced by EigenKernel::enabled().

39 { return _enabled; }

MooseObject::_enabled

const bool & _enabled

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

Definition: MooseObject.h:50

◆ errorPrefix()

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

inlineinherited

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

Definition at line 260 of file MooseBase.h.

260 { return messagePrefix(); }

MooseBase::messagePrefix

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

Definition: MooseBase.h:252

◆ es()

virtual EquationSystems& DisplacedProblem::es ( )

inlineoverridevirtual

Implements SubProblem.

Definition at line 48 of file DisplacedProblem.h.

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

48 { return _eq; }

DisplacedProblem::_eq

EquationSystems _eq

Definition: DisplacedProblem.h:392

◆ finalNonlinearResidual()

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

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 754 of file SubProblem.C.

Referenced by Residual::getValue().

 {
   return 0;
 }

◆ geomSearchData()

virtual GeometricSearchData& DisplacedProblem::geomSearchData ( )

inlineoverridevirtual

Implements SubProblem.

Definition at line 316 of file DisplacedProblem.h.

316 { return _geometric_search_data; }

DisplacedProblem::_geometric_search_data

GeometricSearchData _geometric_search_data

Definition: DisplacedProblem.h:408

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

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

 {
   return _active_elemental_moose_variables[tid];
 }

◆ getActiveFEVariableCoupleableMatrixTags()

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

inherited

Definition at line 390 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 396 of file SubProblem.C.

Referenced by MultiAppVariableValueSamplePostprocessorTransfer::execute().

 {
   return _active_fe_var_coupleable_vector_tags[tid];
 }

◆ getActiveScalarVariableCoupleableMatrixTags()

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

inherited

Definition at line 431 of file SubProblem.C.

Referenced by MooseVariableScalar::reinit().

 {
   return _active_sc_var_coupleable_matrix_tags[tid];
 }

◆ getActiveScalarVariableCoupleableVectorTags()

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

inherited

Definition at line 437 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 796 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 143 of file MooseBase.h.

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

143 { return _pars.getBase(); }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

InputParameters::getBase

const std::string & getBase() const

Definition: InputParameters.C:497

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

Referenced by MaterialPropertyDebugOutput::output().

 {
   return _consumed_material_properties;
 }

◆ getCoordSystem()

Moose::CoordinateSystemType SubProblem::getCoordSystem ( SubdomainID sid ) const

inherited

Definition at line 1278 of file SubProblem.C.

Referenced by BlockRestrictable::getBlockCoordSystem(), MultiApp::getBoundingBox(), Assembly::reinitLowerDElem(), Assembly::reinitNeighborLowerDElem(), and Assembly::setCoordinateTransformation().

 {
   return mesh().getCoordSystem(sid);
 }

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

Referenced by DataFileInterface::getDataFileNameByName().

 {
   // 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.");
 
   // Throw on error so that if getPath() fails, we can throw an error
   // with the context of _parent.mooseError()
   const auto throw_on_error_before = Moose::_throw_on_error;
   Moose::_throw_on_error = true;
   std::optional<std::string> error;
 
   // This will search the data paths for this relative path
   Moose::DataFileUtils::Path found_path;
   try
   {
     found_path = Moose::DataFileUtils::getPath(relative_path);
   }
   catch (std::exception & e)
   {
     error = e.what();
   }
 
   Moose::_throw_on_error = throw_on_error_before;
   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;
 }

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

DisplacedProblem::_displacements

std::vector< std::string > _displacements

Definition: DisplacedProblem.h:395

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

Referenced by FunctorInterface::getFunctorByName().

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

◆ getHitNode()

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

inlineinherited

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

Definition at line 132 of file MooseBase.h.

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

132 { return getHitNode(_pars); }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

MooseBase::getHitNode

const hit::Node * getHitNode() const

Definition: MooseBase.h:132

◆ getLineSearch()

LineSearch * DisplacedProblem::getLineSearch ( )

overridevirtual

Implements SubProblem.

Definition at line 1229 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 489 of file SubProblem.C.

Referenced by MaterialPropertyInterface::getMaterialPropertyBlockNames().

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

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

Referenced by SubProblem::getMaterialPropertyBlockNames(), and MaterialPropertyInterface::getMaterialPropertyBlocks().

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

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

Referenced by MaterialPropertyInterface::getMaterialPropertyBoundaryIDs(), and SubProblem::getMaterialPropertyBoundaryNames().

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

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

Referenced by MaterialPropertyInterface::getMaterialPropertyBoundaryNames().

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

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

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

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

◆ getMooseApp()

MooseApp& MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 83 of file MooseBase.h.

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(), MortarData::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), DefaultConvergenceBase::getSharedExecutionerParam(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

83 { return _app; }

MooseBase::_app

MooseApp & _app

The MOOSE application this is associated with.

Definition: MooseBase.h:353

◆ 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 384 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 421 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 398 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 61 of file MooseObject.C.

Referenced by MFEMProblem::addBoundaryCondition(), MFEMProblem::addKernel(), and MFEMProblem::addMFEMSolver().

 {
   try
   {
     return shared_from_this();
   }
   catch (std::bad_weak_ptr &)
   {
     mooseError(not_shared_error);
   }
 }

◆ getSharedPtr() [2/2]

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

inherited

Definition at line 74 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/4]

virtual MooseVariableFieldBase& SubProblem::getVariable

inline

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/4]

virtual const MooseVariableFieldBase& SubProblem::getVariable

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.

◆ getVariable() [3/4]

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.

Referenced by init().

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

◆ getVariable() [4/4]

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

inlinevirtualinherited

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

◆ getVariableHelper() [1/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 818 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?");
   }
 }

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

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

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

 {
   return _mproblem.getVectorTag(tag_id);
 }

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

Referenced by FEProblemBase::computeLinearSystemSys(), EigenProblem::computeResidualAB(), FEProblemBase::computeResidualAndJacobian(), NonlinearSystemBase::computeResidualInternal(), EigenProblem::computeResidualTag(), ComputeResidualAndJacobianThread::determineObjectWarehouses(), getVectorTags(), SubProblem::numVectorTags(), ComputeMortarFunctor::operator()(), and FEProblemBase::setCurrentResidualVectorTags().

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

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

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

 {
   return _has_active_elemental_moose_variables[tid];
 }

◆ hasAuxiliaryVariable()

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

virtualinherited

Whether or not this problem has this auxiliary variable.

Definition at line 811 of file SubProblem.C.

Referenced by SubProblem::getFunctor(), and NearestNodeValueAux::NearestNodeValueAux().

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

◆ hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

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

Definition at line 138 of file MooseBase.h.

138 { return _pars.hasBase(); }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

InputParameters::hasBase

bool hasBase() const

Definition: InputParameters.C:491

◆ 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 511 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 570 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 1270 of file SubProblem.C.

Referenced by FunctorInterface::isFunctor().

 {
   mooseAssert(tid < _functors.size(), "Too large a thread ID");
   auto & functors = _functors[tid];
   return (functors.find("wraps_" + name) != functors.end());
 }

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

Referenced by SubProblem::getFunctor().

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

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

Referenced by SystemBase::addScalingVector().

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

◆ 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/4]

virtual void SubProblem::haveADObjects

inline

Method for setting whether we have any ad objects.

Definition at line 767 of file SubProblem.h.

767 { _have_ad_objects = have_ad_objects; }

SubProblem::_have_ad_objects

bool _have_ad_objects

AD flag indicating whether any AD objects have been added.

Definition: SubProblem.h:1114

◆ haveADObjects() [2/4]

bool SubProblem::haveADObjects

inline

Method for reading wehther we have any ad objects.

Definition at line 771 of file SubProblem.h.

771 { 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:1114

◆ haveADObjects() [3/4]

void DisplacedProblem::haveADObjects ( bool have_ad_objects )

overridevirtual

Method for setting whether we have any ad objects.

Reimplemented from SubProblem.

Definition at line 1303 of file DisplacedProblem.C.

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

◆ haveADObjects() [4/4]

bool SubProblem::haveADObjects ( ) const

inlineinherited

Method for reading wehther we have any ad objects.

Definition at line 771 of file SubProblem.h.

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

771 { 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:1114

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

Referenced by init(), and updateMesh().

 {
   return _mproblem.haveFV();
 }

◆ havePRefinement()

bool SubProblem::havePRefinement ( ) const

inlineinherited

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

Definition at line 1009 of file SubProblem.h.

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

1009 { 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:1202

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

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

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

◆ 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 730 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 201 of file MooseBase.h.

Referenced by SetupDebugAction::act(), ADConservativeAdvectionBC::ADConservativeAdvectionBC(), DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), MFEMMesh::buildMesh(), LibtorchNeuralNetControl::conditionalParameterError(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), ElementSubdomainModifierBase::ElementSubdomainModifierBase(), MooseApp::errorCheck(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PiecewiseTabularBase::PiecewiseTabularBase(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::runInputFile(), MooseApp::runInputs(), MFEMSolverBase::setPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), TimedSubdomainModifier::TimedSubdomainModifier(), and XYDelaunayGenerator::XYDelaunayGenerator().

   {
     return _pars.isParamSetByUser(name);
   }

◆ 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 195 of file MooseBase.h.

195 { return _pars.isParamValid(name); }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

MooseBase::name

const std::string & name() const

Get the name of the class.

Definition: MooseBase.h:99

InputParameters::isParamValid

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

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

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.

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

43 { return _termination_requested; };

Problem::_termination_requested

bool _termination_requested

True if termination of the solve has been requested.

Definition: Problem.h:58

◆ 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 1293 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 1395 of file DisplacedProblem.C.

 {
   return _mproblem.linearSysNum(sys_name);
 }

◆ markFamilyPRefinement()

void SubProblem::markFamilyPRefinement ( const InputParameters & params )

protectedinherited

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

Definition at line 1367 of file SubProblem.C.

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

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

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

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

 {
   _material_property_requested.insert(prop_name);
 }

◆ 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 MooseMesh& DisplacedProblem::mesh ( )

inlineoverridevirtual

Implements SubProblem.

Definition at line 49 of file DisplacedProblem.h.

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

49 { return _mesh; }

DisplacedProblem::_mesh

MooseMesh & _mesh

Definition: DisplacedProblem.h:391

◆ mesh() [2/4]

virtual const MooseMesh& DisplacedProblem::mesh ( ) const

inlineoverridevirtual

Implements SubProblem.

Definition at line 50 of file DisplacedProblem.h.

50 { return _mesh; }

DisplacedProblem::_mesh

MooseMesh & _mesh

Definition: DisplacedProblem.h:391

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

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 252 of file MooseBase.h.

Referenced by MooseBase::callMooseError(), MooseBase::errorPrefix(), MooseBase::mooseDeprecated(), MooseBase::mooseInfo(), and MooseBase::mooseWarning().

   {
     return messagePrefix(_pars, hit_prefix);
   }

◆ mooseDeprecated()

template<typename... Args>

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

inlineinherited

Definition at line 310 of file MooseBase.h.

Referenced by FEProblemBase::addAuxArrayVariable(), FEProblemBase::addAuxScalarVariable(), FEProblemBase::addAuxVariable(), FEProblemBase::advanceMultiApps(), MultiApp::appProblem(), MooseMesh::buildSideList(), ChangeOverTimestepPostprocessor::ChangeOverTimestepPostprocessor(), AddVariableAction::determineType(), EigenProblem::EigenProblem(), Eigenvalue::Eigenvalue(), MooseMesh::elem(), UserForcingFunction::f(), FaceFaceConstraint::FaceFaceConstraint(), FunctionDT::FunctionDT(), RandomICBase::generateRandom(), MooseMesh::getBoundariesToElems(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), Control::getExecuteOptions(), FEProblemBase::getNonlinearSystem(), MooseApp::getRecoverFileBase(), FEProblemBase::getUserObjects(), FEProblemBase::hasPostprocessor(), MooseApp::hasRecoverFileBase(), MatDiffusionBase< Real >::MatDiffusionBase(), MultiAppNearestNodeTransfer::MultiAppNearestNodeTransfer(), MultiAppShapeEvaluationTransfer::MultiAppShapeEvaluationTransfer(), MultiAppUserObjectTransfer::MultiAppUserObjectTransfer(), NodalScalarKernel::NodalScalarKernel(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), PercentChangePostprocessor::PercentChangePostprocessor(), ReferenceResidualConvergence::ReferenceResidualConvergence(), Residual::Residual(), MooseMesh::setBoundaryToNormalMap(), Exodus::setOutputDimension(), MooseApp::setupOptions(), UserForcingFunction::UserForcingFunction(), and VariableResidual::VariableResidual().

   {
     moose::internal::mooseDeprecatedStream(
         _console, false, true, 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 273 of file MooseBase.h.

Referenced by ArrayDGLowerDKernel::ArrayDGLowerDKernel(), ArrayHFEMDirichletBC::ArrayHFEMDirichletBC(), ArrayLowerDIntegratedBC::ArrayLowerDIntegratedBC(), DGLowerDKernel::DGLowerDKernel(), HFEMDirichletBC::HFEMDirichletBC(), and LowerDIntegratedBC::LowerDIntegratedBC().

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

◆ mooseError()

template<typename... Args>

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

inlineinherited

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

Definition at line 267 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 286 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 317 of file MooseBase.h.

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), MultiAppGeneralFieldNearestLocationTransfer::evaluateInterpValuesNearestNode(), PIDTransientControl::execute(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), DataFileInterface::getDataFilePath(), MFEMScalarFESpace::getFECName(), MultiAppTransfer::getPointInTargetAppFrame(), ImplicitMidpoint::ImplicitMidpoint(), ParsedDownSelectionPositions::initialize(), PropertyReadFile::initialize(), MultiAppGeneralFieldTransfer::initialSetup(), InversePowerMethod::InversePowerMethod(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), PNGOutput::makeMeshFunc(), NonlinearEigen::NonlinearEigen(), SolutionInvalidityOutput::output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramInfo(), ProjectionAux::ProjectionAux(), ReferenceResidualConvergence::ReferenceResidualConvergence(), MFEMDataCollection::registerFields(), FEProblemBase::setRestartFile(), MooseApp::setupOptions(), SolutionUserObjectBase::SolutionUserObjectBase(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

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

◆ mooseWarning()

template<typename... Args>

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

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 295 of file MooseBase.h.

Referenced by CopyMeshPartitioner::_do_partition(), AddKernelAction::act(), MeshOnlyAction::act(), AddFunctionAction::act(), MaterialOutputAction::act(), CommonOutputAction::act(), MFEMProblem::addFunction(), MooseMesh::addPeriodicVariable(), DiracKernelBase::addPoint(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), MultiAppVariableValueSamplePostprocessorTransfer::cacheElemToPostprocessorData(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), SampledOutput::cloneMesh(), MultiAppGeneralFieldTransfer::closestToPosition(), VariableValueElementSubdomainModifier::computeSubdomainID(), GapValueAux::computeValue(), MultiApp::createApp(), DebugResidualAux::DebugResidualAux(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), ElementMaterialSampler::ElementMaterialSampler(), Postprocessor::evaluateDotWarning(), MeshDivisionFunctorReductionVectorPostprocessor::execute(), ElementQualityChecker::finalize(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), SubdomainPerElementGenerator::generate(), StitchMeshGenerator::generate(), ParsedGenerateSideset::generate(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), DataFileInterface::getDataFilePath(), PointSamplerBase::getLocalElemContainingPoint(), FEProblemBase::getMaterial(), LineValueSampler::getValue(), Terminator::handleMessage(), IndicatorMarker::IndicatorMarker(), CartesianGridDivision::initialize(), CylindricalGridDivision::initialize(), SphericalGridDivision::initialize(), ElementGroupCentroidPositions::initialize(), MultiAppGeneralFieldNearestLocationTransfer::initialSetup(), BoundsBase::initialSetup(), ReferenceResidualConvergence::initialSetup(), MultiAppGeneralFieldTransfer::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), MaterialBase::initStatefulProperties(), LeastSquaresFit::LeastSquaresFit(), IterationAdaptiveDT::limitDTToPostprocessorValue(), MooseApp::loadLibraryAndDependencies(), FEProblemBase::mesh(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), NewmarkBeta::NewmarkBeta(), NodalPatchRecovery::NodalPatchRecovery(), NonlocalIntegratedBC::NonlocalIntegratedBC(), NonlocalKernel::NonlocalKernel(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), MooseBase::paramWarning(), PiecewiseConstantFromCSV::PiecewiseConstantFromCSV(), Executioner::problem(), PropertyReadFile::readData(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), MooseMesh::setCoordSystem(), SidesetAroundSubdomainUpdater::SidesetAroundSubdomainUpdater(), FEProblemBase::sizeZeroes(), TransientMultiApp::solveStep(), Tecplot::Tecplot(), TimeDerivativeAux::TimeDerivativeAux(), Checkpoint::updateCheckpointFiles(), SampledOutput::updateSample(), PiecewiseConstantFromCSV::value(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

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

◆ mooseWarningNonPrefixed()

template<typename... Args>

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

inlineinherited

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

Definition at line 304 of file MooseBase.h.

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

◆ name()

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

inlineinherited

Get the name of the class.

Returns: The name of the class

Definition at line 99 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 1371 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 716 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 766 of file SubProblem.C.

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

 {
   return 0;
 }

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

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

 {
   return 0;
 }

◆ 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 1407 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 1341 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 1335 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 1347 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 1189 of file DisplacedProblem.C.

1190 {

1191 }

◆ onTimestepEnd()

void DisplacedProblem::onTimestepEnd ( )

overridevirtual

Implements SubProblem.

Definition at line 1194 of file DisplacedProblem.C.

1195 {

1196 }

◆ 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 435 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 127 of file MooseBase.h.

127 { return _pars; }

MooseBase::_pars

const InputParameters & _pars

The object's parameters.

Definition: MooseBase.h:362

◆ 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 449 of file MooseBase.h.

Referenced by GridPartitioner::_do_partition(), ComboMarker::ComboMarker(), Control::Control(), FunctorIC::FunctorIC(), and TransientMultiApp::TransientMultiApp().

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

◆ paramWarning()

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 442 of file MooseBase.h.

Referenced by GridPartitioner::_do_partition(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), CombinerGenerator::copyIntoMesh(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), UniqueExtraIDMeshGenerator::generate(), PlaneIDMeshGenerator::generate(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

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

◆ perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 78 of file PerfGraphInterface.C.

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), and PerfGraphOutput::output().

 {
   return _pg_moose_app.perfGraph();
 }

◆ prepare() [1/2]

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

overridevirtual

Implements SubProblem.

◆ prepare() [2/2]

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

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

◆ 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 1096 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 1102 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 1332 of file SubProblem.C.

Referenced by FEProblemBase::init().

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

◆ prepareShapes()

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

overridevirtual

Implements SubProblem.

Definition at line 1090 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 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 391 of file MooseBase.h.

 {
   return isParamValid(name) ? &getParam<T>(name) : nullptr;
 }

◆ refMesh()

MooseMesh & DisplacedProblem::refMesh ( )

Definition at line 1171 of file DisplacedProblem.C.

Referenced by updateMesh().

 {
   return _ref_mesh;
 }

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

Referenced by reinitDirac(), and reinitElemPhys().

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

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

Referenced by FEProblemBase::reinitElemFaceRef().

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

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

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

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

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

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

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

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

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

◆ reinitNeighbor() [1/2]

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

overridevirtual

Implements SubProblem.

Referenced by reinitElemNeighborAndLowerD().

◆ 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

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

Referenced by FEProblemBase::reinitNeighborFaceRef().

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

◆ reinitNeighborLowerDElem()

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

inherited

reinitialize a neighboring lower dimensional element

Definition at line 987 of file SubProblem.C.

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

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

◆ reinitNeighborPhys() [1/2]

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

overridevirtual

Implements SubProblem.

◆ reinitNeighborPhys() [2/2]

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

overridevirtual

Implements SubProblem.

◆ 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 1067 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 1110 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 1283 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();
 }

◆ safeAccessTaggedMatrices()

bool DisplacedProblem::safeAccessTaggedMatrices ( ) const

overridevirtual

Is it safe to access the tagged matrices.

Reimplemented from SubProblem.

Definition at line 1359 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 1365 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 300 of file SubProblem.C.

Referenced by FEProblemBase::computeLinearSystemSys().

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

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

Referenced by FEProblemBase::computeLinearSystemSys(), FEProblemBase::computeResidualAndJacobian(), and ComputeResidualAndJacobianThread::determineObjectWarehouses().

 {
   selected_tags.clear();
   for (const auto & vector_tag : input_vector_tags)
     if (system.hasVector(vector_tag._id))
       selected_tags.insert(vector_tag._id);
 }

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

Referenced by FEProblemBase::setActiveElementalMooseVariables().

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

◆ setActiveFEVariableCoupleableMatrixTags()

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

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 363 of file SubProblem.C.

Referenced by FEProblemBase::setActiveFEVariableCoupleableMatrixTags().

 {
   _active_fe_var_coupleable_matrix_tags[tid] = mtags;
 }

◆ setActiveFEVariableCoupleableVectorTags()

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

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 369 of file SubProblem.C.

Referenced by FEProblemBase::setActiveFEVariableCoupleableVectorTags().

 {
   _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);
 }

◆ setActiveScalarVariableCoupleableMatrixTags()

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

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 402 of file SubProblem.C.

Referenced by FEProblemBase::setActiveScalarVariableCoupleableMatrixTags().

 {
   _active_sc_var_coupleable_matrix_tags[tid] = mtags;
 }

◆ setActiveScalarVariableCoupleableVectorTags()

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

virtualinherited

Reimplemented in FEProblemBase.

Definition at line 409 of file SubProblem.C.

Referenced by FEProblemBase::setActiveScalarVariableCoupleableVectorTags().

 {
   _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);
 }

◆ setCurrentBoundaryID()

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

virtualinherited

sets the current boundary ID in assembly

Reimplemented in FEProblemBase.

Definition at line 789 of file SubProblem.C.

Referenced by FEProblemBase::setCurrentBoundaryID().

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

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

Referenced by FEProblemBase::setCurrentLowerDElem().

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

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

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

   {
     _currently_computing_jacobian = currently_computing_jacobian;
   }

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

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

 {
   _currently_computing_residual_and_jacobian = currently_computing_residual_and_jacobian;
 }

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

924 { _output_functors = set_output; }

SubProblem::_output_functors

bool _output_functors

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

Definition: SubProblem.h:1164

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

◆ setResidual() [1/2]

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

overridevirtual

Definition at line 989 of file DisplacedProblem.C.

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

◆ setResidual() [2/2]

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

pure virtualinherited

◆ setResidualNeighbor() [1/2]

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

overridevirtual

Definition at line 998 of file DisplacedProblem.C.

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

◆ setResidualNeighbor() [2/2]

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

pure virtualinherited

◆ solverSys()

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

inline

Definition at line 476 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 1401 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 1177 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 615 of file SubProblem.C.

Referenced by MaterialPropertyInterface::checkMaterialProperty().

 {
   _map_boundary_material_props_check[boundary_id].insert(std::make_pair(requestor, name));
 }

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

Referenced by MaterialBase::registerPropName().

 {
   _map_boundary_material_props[boundary_id].insert(name);
 }

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

Referenced by MaterialBase::storeBoundaryZeroMatProp().

 {
   _zero_boundary_material_props[boundary_id].insert(name);
 }

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

Referenced by MaterialPropertyInterface::checkMaterialProperty().

 {
   _map_block_material_props_check[block_id].insert(std::make_pair(requestor, name));
 }

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

Referenced by MaterialBase::registerPropName().

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

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

Referenced by MaterialBase::storeSubdomainZeroMatProp().

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

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

Referenced by syncSolutions().

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

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

Referenced by updateMesh().

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

◆ 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

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

DisplacedProblem::_displaced_aux

std::unique_ptr< DisplacedSystem > _displaced_aux

Definition: DisplacedProblem.h:398

◆ systemBaseAuxiliary() [2/2]

virtual SystemBase& DisplacedProblem::systemBaseAuxiliary ( )

inlineoverridevirtual

Implements SubProblem.

Definition at line 71 of file DisplacedProblem.h.

71 { return *_displaced_aux; }

DisplacedProblem::_displaced_aux

std::unique_ptr< DisplacedSystem > _displaced_aux

Definition: DisplacedProblem.h:398

◆ 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 500 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 506 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 484 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 492 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 512 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 520 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.

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

37 { _termination_requested = true; };

Problem::_termination_requested

bool _termination_requested

True if termination of the solve has been requested.

Definition: Problem.h:58

◆ 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 47 of file PerfGraphInterface.C.

Referenced by PerfGraphInterface::registerTimedSection().

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

◆ timestepSetup()

void DisplacedProblem::timestepSetup ( )

overridevirtual

Reimplemented from SubProblem.

Definition at line 1263 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 89 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 54 of file MooseBase.C.

Referenced by FEProblemBase::addPostprocessor(), MaterialPropertyStorage::addProperty(), FEProblemBase::addReporter(), FEProblemBase::addVectorPostprocessor(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< std::vector< T > >::finalize(), and ReporterData::getReporterInfo().

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

◆ undisplaceMesh()

void DisplacedProblem::undisplaceMesh ( )

Resets the displaced mesh to the reference mesh.

Required when refining the DisplacedMesh.

Definition at line 1199 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 66 of file MooseBase.C.

Referenced by MooseBase::connectControllableParams(), and Action::uniqueActionName().

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

◆ 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 60 of file MooseBase.C.

 {
   return MooseObjectParameterName(getBase(), name(), parameter_name);
 }

◆ updateGeomSearch()

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

overridevirtual

Implements SubProblem.

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

Referenced by meshChanged().

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

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

Referenced by SystemBase::zeroTaggedVector().

 {
   return _not_zeroed_tagged_vectors.count(tag);
 }

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

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

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

Friends And Related Function Documentation

◆ Restartable

friend class Restartable

friend

Definition at line 472 of file DisplacedProblem.h.

◆ UpdateDisplacedMeshThread

friend class UpdateDisplacedMeshThread

friend

Definition at line 471 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 1075 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 1081 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 1083 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 1085 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 1087 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 353 of file MooseBase.h.

◆ _assembly

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

protected

◆ _aux_solution

const NumericVector<Number>* DisplacedProblem::_aux_solution

protected

The auxiliary system solution.

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

Referenced by SubProblem::computingNonlinearResid(), and FEProblemBase::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.

◆ _currently_computing_jacobian

bool SubProblem::_currently_computing_jacobian

protectedinherited

Flag to determine whether the problem is currently computing Jacobian.

Definition at line 1096 of file SubProblem.h.

Referenced by EigenProblem::computeJacobianBlocks(), FEProblemBase::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 1105 of file SubProblem.h.

Referenced by SubProblem::currentlyComputingResidual(), SubProblem::setCurrentlyComputingResidual(), and FEProblemBase::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 1099 of file SubProblem.h.

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

◆ _default_ghosting

bool SubProblem::_default_ghosting

protectedinherited

Whether or not to use default libMesh coupling.

Definition at line 1090 of file SubProblem.h.

Referenced by SubProblem::defaultGhosting().

◆ _dirac_kernel_info

DiracKernelInfo SubProblem::_dirac_kernel_info

protectedinherited

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

◆ _displacements

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

protected

Definition at line 395 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 50 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _eq

EquationSystems DisplacedProblem::_eq

protected

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

◆ _geometric_search_data

GeometricSearchData DisplacedProblem::_geometric_search_data

protected

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

Referenced by FEProblemBase::addGhostedElem(), SubProblem::ghostedElems(), FEProblemBase::initialSetup(), 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 1079 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 1114 of file SubProblem.h.

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

◆ _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 1052 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 1070 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 1055 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 1071 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 1062 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 1044 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 1041 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 391 of file DisplacedProblem.h.

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

◆ _mproblem

FEProblemBase& DisplacedProblem::_mproblem

protected

Definition at line 390 of file DisplacedProblem.h.

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

◆ _name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 359 of file MooseBase.h.

◆ _nl_solution

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

protected

The nonlinear system solutions.

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

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

◆ _pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 362 of file MooseBase.h.

Referenced by AddFVICAction::act(), AddICAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupMeshAction::act(), ComposeTimeStepperAction::act(), SetupDebugAction::act(), AddAuxKernelAction::act(), AddPeriodicBCAction::act(), CommonOutputAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGeneratorBase::BreakMeshByBlockGeneratorBase(), PiecewiseTabularBase::buildFromFile(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), GlobalParamsAction::parameters(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), Eigenvalue::prepareSolverOptions(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

◆ _pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 124 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 127 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

◆ _ref_mesh

MooseMesh& DisplacedProblem::_ref_mesh

protected

reference mesh

Definition at line 394 of file DisplacedProblem.h.

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

◆ _safe_access_tagged_matrices

bool SubProblem::_safe_access_tagged_matrices

protectedinherited

Is it safe to retrieve data from tagged matrices.

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

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

◆ _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 356 of file MooseBase.h.

Referenced by ExplicitTimeIntegrator::ExplicitTimeIntegrator(), FEProblemSolve::FEProblemSolve(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), FillBetweenCurvesGenerator::generate(), ExplicitTimeIntegrator::init(), FEProblemBase::init(), MooseBase::MooseBase(), MooseStaticCondensationPreconditioner::MooseStaticCondensationPreconditioner(), PhysicsBasedPreconditioner::PhysicsBasedPreconditioner(), FEProblemBase::solverTypeString(), and MooseBase::type().

◆ _var_dof_map

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

inherited

Definition at line 674 of file SubProblem.h.

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

◆ _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 1058 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 1059 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(), Factory::getValidParams(), ActionFactory::getValidParams(), AutomaticMortarGeneration::initOutput(), SetupMeshAction::modifyParamsForUseSplit(), and MortarNodalGeometryOutput::validParams().

◆ 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(), MooseObjectUnitTest::buildObjects(), ActionFactory::create(), 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(), 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().

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

Friends

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

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/2]

◆ addJacobianNeighbor() [2/2]

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

◆ clearActiveElementalMooseVariables()

◆ clearActiveFEVariableCoupleableMatrixTags()

◆ clearActiveFEVariableCoupleableVectorTags()

◆ clearActiveScalarVariableCoupleableMatrixTags()

◆ clearActiveScalarVariableCoupleableVectorTags()

◆ clearAllDofIndices()

◆ clearDiracInfo()

◆ computingNonlinearResid() [1/2]

◆ computingNonlinearResid() [2/2]

◆ computingPreSMOResidual()

◆ computingScalingJacobian()

◆ computingScalingResidual()

◆ connectControllableParams()

◆ console()

◆ converged()

◆ couplingMatrix()

◆ createQRules()