NeighborCoupleableMooseVariableDependencyIntermediateInterface Class Reference

Intermediate base class that ties together all the interfaces for getting MooseVariables with the MooseVariableDependencyInterface. More...

#include <NeighborCoupleableMooseVariableDependencyIntermediateInterface.h>

Inheritance diagram for NeighborCoupleableMooseVariableDependencyIntermediateInterface:

Public Member Functions
	NeighborCoupleableMooseVariableDependencyIntermediateInterface (const MooseObject *moose_object, bool nodal, bool neighbor_nodal, bool is_fv=false)
virtual const VariableValue &	coupledNeighborValue (const std::string &var_name, unsigned int comp=0) const
std::vector< const VariableValue * >	coupledNeighborValues (const std::string &var_name) const
std::vector< const VariableValue * >	coupledNeighborValuesOld (const std::string &var_name) const
std::vector< const VariableValue * >	coupledNeighborValuesOlder (const std::string &var_name) const
virtual const ADVariableValue &	adCoupledNeighborValue (const std::string &var_name, unsigned int comp=0) const
	Get the coupled neighbor variable value for var_name with derivative information for automatic differentiation objects. More...
template<bool is_ad>
const auto &	coupledGenericNeighborValue (const std::string &var_name, unsigned int comp=0) const
	Retrieve the coupled neighbor variable value whether AD or not. More...
template<bool is_ad>
const auto &	coupledGenericNeighborGradient (const std::string &var_name, unsigned int comp=0) const
	Retrieve the coupled neighbor variable gradient whether AD or not. More...
virtual const ADVariableValue &	adCoupledNeighborValueDot (const std::string &var_name, unsigned int comp=0) const
	Get the time derivative of the coupled neighbor variable value for var_name with derivative information for automatic differentiation objects. More...
std::vector< const ADVariableValue * >	adCoupledNeighborValues (const std::string &var_name) const
virtual const ADVectorVariableValue &	adCoupledVectorNeighborValue (const std::string &var_name, unsigned int comp=0) const
	Get the coupled neighbor vector variable value for var_name with derivative information for automatic differentiation objects. More...
virtual const VariableValue &	coupledNeighborValueDot (const std::string &var_name, unsigned int comp=0) const
virtual const VariableValue &	coupledNeighborValueDotDu (const std::string &var_name, unsigned int comp=0) const
virtual const VariableValue &	coupledNeighborValueOld (const std::string &var_name, unsigned int comp=0) const
virtual const VariableValue &	coupledNeighborValueOlder (const std::string &var_name, unsigned int comp=0) const
virtual const VariableGradient &	coupledNeighborGradient (const std::string &var_name, unsigned int comp=0) const
virtual std::vector< const VariableGradient * >	coupledNeighborGradients (const std::string &var_name) const
virtual const VariableGradient &	coupledNeighborGradientOld (const std::string &var_name, unsigned int comp=0) const
virtual const VariableGradient &	coupledNeighborGradientOlder (const std::string &var_name, unsigned int comp=0) const
virtual const ADVariableGradient &	adCoupledNeighborGradient (const std::string &var_name, unsigned int comp=0) const
	Get the coupled neighbor variable gradient for var_name with derivative information for automatic differentiation objects. More...
virtual const VectorVariableGradient &	coupledVectorNeighborGradient (const std::string &var_name, unsigned int comp=0) const
virtual const VectorVariableGradient &	coupledVectorNeighborGradientOld (const std::string &var_name, unsigned int comp=0) const
virtual const VectorVariableGradient &	coupledVectorNeighborGradientOlder (const std::string &var_name, unsigned int comp=0) const
virtual const ArrayVariableValue &	coupledArrayNeighborValue (const std::string &var_name, unsigned int comp=0) const
virtual const ArrayVariableGradient &	coupledArrayNeighborGradient (const std::string &var_name, unsigned int comp=0) const
virtual const ArrayVariableGradient &	coupledArrayNeighborGradientOld (const std::string &var_name, unsigned int comp=0) const
virtual const ArrayVariableGradient &	coupledArrayNeighborGradientOlder (const std::string &var_name, unsigned int comp=0) const
virtual const VariableSecond &	coupledNeighborSecond (const std::string &var_name, unsigned int i=0) const
virtual const VariableValue &	coupledNeighborDofValues (const std::string &var_name, unsigned int comp=0) const
virtual const VariableValue &	coupledNeighborDofValuesOld (const std::string &var_name, unsigned int comp=0) const
virtual const VariableValue &	coupledNeighborDofValuesOlder (const std::string &var_name, unsigned int comp=0) const
const std::unordered_map< std::string, std::vector< MooseVariableFieldBase * > > &	getCoupledVars () const
	Get the list of coupled variables. More...
const std::vector< MooseVariableFieldBase * > &	getCoupledMooseVars () const
	Get the list of all coupled variables. More...
const std::vector< MooseVariable * > &	getCoupledStandardMooseVars () const
	Get the list of standard coupled variables. More...
const std::vector< VectorMooseVariable * > &	getCoupledVectorMooseVars () const
	Get the list of vector coupled variables. More...
const std::vector< ArrayMooseVariable * > &	getCoupledArrayMooseVars () const
	Get the list of array coupled variables. More...
void	addFEVariableCoupleableVectorTag (TagID tag)
void	addFEVariableCoupleableMatrixTag (TagID tag)
std::set< TagID > &	getFEVariableCoupleableVectorTags ()
const std::set< TagID > &	getFEVariableCoupleableVectorTags () const
std::set< TagID > &	getFEVariableCoupleableMatrixTags ()
const std::set< TagID > &	getFEVariableCoupleableMatrixTags () const
auto &	getWritableCoupledVariables () const
	returns a reference to the set of writable coupled variables More...
bool	hasWritableCoupledVariables () const
	Checks whether the object has any writable coupled variables. More...
const ADVariableValue *	getADDefaultValue (const std::string &var_name) const
	Helper method to return (and insert if necessary) the default value for Automatic Differentiation for an uncoupled variable. More...
const ADVectorVariableValue *	getADDefaultVectorValue (const std::string &var_name) const
	Helper method to return (and insert if necessary) the default vector value for Automatic Differentiation for an uncoupled variable. More...
const ADVariableGradient &	getADDefaultGradient () const
	Helper method to return (and insert if necessary) the default gradient for Automatic Differentiation for an uncoupled variable. More...
const ADVectorVariableGradient &	getADDefaultVectorGradient () const
	Helper method to return (and insert if necessary) the default gradient for Automatic Differentiation for an uncoupled vector variable. More...
const ADVariableSecond &	getADDefaultSecond () const
	Helper method to return (and insert if necessary) the default second derivatives for Automatic Differentiation for an uncoupled variable. More...
const std::vector< MooseVariableScalar * > &	getCoupledMooseScalarVars ()
	Get the list of coupled scalar variables. More...
const std::set< TagID > &	getScalarVariableCoupleableVectorTags () const
const std::set< TagID > &	getScalarVariableCoupleableMatrixTags () const
const std::set< MooseVariableFieldBase * > &	getMooseVariableDependencies () const
	Retrieve the set of MooseVariableFieldBase that this object depends on. More...
template<typename DofObjectType >
std::set< MooseVariableFieldBase * >	checkAllVariables (const DofObjectType &dof_object, const std::set< MooseVariableFieldBase *> &vars_to_omit={})
	Check whether all of the variable dependencies have degree of freedom indices on the supplied degree of freedom object. More...
template<typename DofObjectType >
std::set< MooseVariableFieldBase * >	checkVariables (const DofObjectType &dof_object, const std::set< MooseVariableFieldBase *> &vars_to_check)
	Check whether all of the supplied variables have degree of freedom indices on the supplied degree of freedom object. More...

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
virtual void	coupledCallback (const std::string &, bool) const
	A call-back function provided by the derived object for actions before coupling a variable with functions such as coupledValue. More...
virtual bool	isCoupled (const std::string &var_name, unsigned int i=0) const
	Returns true if a variables has been coupled as name. More...
virtual bool	isCoupledConstant (const std::string &var_name) const
	Returns true if a variable passed as a coupled value is really a constant. More...
unsigned int	coupledComponents (const std::string &var_name) const
	Number of coupled components. More...
VariableName	coupledName (const std::string &var_name, unsigned int comp=0) const
	Names of the variable in the Coupleable interface. More...
std::vector< VariableName >	coupledNames (const std::string &var_name) const
	Names of the variables in the Coupleable interface. More...
virtual unsigned int	coupled (const std::string &var_name, unsigned int comp=0) const
	Returns the index for a coupled variable by name. More...
std::vector< unsigned int >	coupledIndices (const std::string &var_name) const
	Returns the indices for a coupled variable's components. More...
virtual const VariableValue &	coupledValue (const std::string &var_name, unsigned int comp=0) const
	Returns value of a coupled variable. More...
std::vector< const VariableValue * >	coupledValues (const std::string &var_name) const
	Returns the values for all of a coupled variable components. More...
std::vector< const VectorVariableValue * >	coupledVectorValues (const std::string &var_name) const
	Returns the values for all of a coupled vector variable's components. More...
template<bool is_ad>
const GenericVariableValue< is_ad > &	coupledGenericValue (const std::string &var_name, unsigned int comp=0) const
	Returns value of a coupled variable for use in templated automatic differentiation classes. More...
template<>
const GenericVariableValue< false > &	coupledGenericValue (const std::string &var_name, unsigned int comp) const
template<>
const GenericVariableValue< true > &	coupledGenericValue (const std::string &var_name, unsigned int comp) const
template<bool is_ad>
std::vector< const GenericVariableValue< is_ad > * >	coupledGenericValues (const std::string &var_name) const
	Returns the values for all of a coupled variable's components for use in templated automatic differentiation classes. More...
template<>
std::vector< const GenericVariableValue< false > * >	coupledGenericValues (const std::string &var_name) const
template<>
std::vector< const GenericVariableValue< true > * >	coupledGenericValues (const std::string &var_name) const
template<bool is_ad>
const GenericVariableValue< is_ad > &	coupledGenericDofValue (const std::string &var_name, unsigned int comp=0) const
	Returns DOF value of a coupled variable for use in templated automatic differentiation classes. More...
template<>
const GenericVariableValue< false > &	coupledGenericDofValue (const std::string &var_name, unsigned int comp) const
template<>
const GenericVariableValue< true > &	coupledGenericDofValue (const std::string &var_name, unsigned int comp) const
virtual const VariableValue &	coupledValueLower (const std::string &var_name, unsigned int comp=0) const
	Returns value of a coupled lower-dimensional variable. More...
const ADVariableValue &	adCoupledValue (const std::string &var_name, unsigned int comp=0) const
	Returns value of a coupled variable for use in Automatic Differentiation. More...
std::vector< const ADVariableValue * >	adCoupledValues (const std::string &var_name) const
	Returns the values for all of a coupled variable's components for use in Automatic Differentiation. More...
const ADVariableValue &	adCoupledLowerValue (const std::string &var_name, unsigned int comp=0) const
	Returns value of a coupled lower-dimensional variable for use in Automatic Differentiation. More...
const ADVectorVariableValue &	adCoupledVectorValue (const std::string &var_name, unsigned int comp=0) const
	Returns value of a coupled vector variable for use in Automatic Differentiation. More...
std::vector< const ADVectorVariableValue * >	adCoupledVectorValues (const std::string &var_name) const
	Returns the values for all of a coupled vector variable's components for use in Automatic Differentiation. More...
virtual const VariableValue &	coupledVectorTagValue (const std::string &var_names, TagID tag, unsigned int index=0) const
	Returns value of a coupled variable for a given tag. More...
virtual const VariableValue &	coupledVectorTagValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const
std::vector< const VariableValue * >	coupledVectorTagValues (const std::string &var_names, TagID tag) const
	Returns the values for all the coupled variables desired for a given tag. More...
std::vector< const VariableValue * >	coupledVectorTagValues (const std::string &var_names, const std::string &tag_name) const
virtual const ArrayVariableValue &	coupledVectorTagArrayValue (const std::string &var_names, TagID tag, unsigned int index=0) const
	Returns value of a coupled array variable for a given tag. More...
virtual const ArrayVariableValue &	coupledVectorTagArrayValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const
std::vector< const ArrayVariableValue * >	coupledVectorTagArrayValues (const std::string &var_names, TagID tag) const
	Returns the values for all the coupled variables desired for a given tag. More...
std::vector< const ArrayVariableValue * >	coupledVectorTagArrayValues (const std::string &var_names, const std::string &tag_name) const
virtual const VariableGradient &	coupledVectorTagGradient (const std::string &var_names, TagID tag, unsigned int index=0) const
	Returns gradient of a coupled variable for a given tag. More...
virtual const VariableGradient &	coupledVectorTagGradient (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const
std::vector< const VariableGradient * >	coupledVectorTagGradients (const std::string &var_names, TagID tag) const
	Returns gradients for all the coupled variables desired for a given tag. More...
std::vector< const VariableGradient * >	coupledVectorTagGradients (const std::string &var_names, const std::string &tag_name) const
virtual const ArrayVariableGradient &	coupledVectorTagArrayGradient (const std::string &var_names, TagID tag, unsigned int index=0) const
	Returns gradient of a coupled array variable for a given tag. More...
virtual const ArrayVariableGradient &	coupledVectorTagArrayGradient (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const
std::vector< const ArrayVariableGradient * >	coupledVectorTagArrayGradients (const std::string &var_names, TagID tag) const
	Returns gradients for all the coupled variables desired for a given tag. More...
std::vector< const ArrayVariableGradient * >	coupledVectorTagArrayGradients (const std::string &var_names, const std::string &tag_name) const
virtual const VariableValue &	coupledVectorTagDofValue (const std::string &var_name, TagID tag, unsigned int index=0) const
	Returns dof value of a coupled variable for a given tag. More...
virtual const VariableValue &	coupledVectorTagDofValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const
const ArrayVariableValue &	coupledVectorTagArrayDofValue (const std::string &var_name, const std::string &tag_name, unsigned int comp=0) const
	Returns evaluations of a tagged vector at the requested variable's degree of freedom indices. More...
std::vector< const VariableValue * >	coupledVectorTagDofValues (const std::string &var_names, TagID tag) const
	Returns the dof values for all the coupled variables desired for a given tag. More...
std::vector< const VariableValue * >	coupledVectorTagDofValues (const std::string &var_names, const std::string &tag_name) const
virtual const VariableValue &	coupledMatrixTagValue (const std::string &var_names, TagID tag, unsigned int index=0) const
	Returns value of a coupled variable for a given tag. More...
virtual const VariableValue &	coupledMatrixTagValue (const std::string &var_names, const std::string &tag_name, unsigned int index=0) const
std::vector< const VariableValue * >	coupledMatrixTagValues (const std::string &var_names, TagID tag) const
	Returns the diagonal matrix values for all the coupled variables desired for a given tag. More...
std::vector< const VariableValue * >	coupledMatrixTagValues (const std::string &var_names, const std::string &tag_name) const
virtual const VectorVariableValue &	coupledVectorValue (const std::string &var_name, unsigned int comp=0) const
	Returns value of a coupled vector variable. More...
virtual const ArrayVariableValue &	coupledArrayValue (const std::string &var_name, unsigned int comp=0) const
	Returns value of a coupled array variable. More...
std::vector< const ArrayVariableValue * >	coupledArrayValues (const std::string &var_name) const
	Returns the values for all of a coupled array variable's components. More...
MooseWritableVariable &	writableVariable (const std::string &var_name, unsigned int comp=0)
	Returns a writable MooseVariable object for a nodal or elemental variable. More...
virtual VariableValue &	writableCoupledValue (const std::string &var_name, unsigned int comp=0)
	Returns a writable reference to a coupled variable for writing to multiple AuxVariables from a single AuxKernel or a UserObject. More...
void	checkWritableVar (MooseWritableVariable *var)
	Checks that the passed in variable is only accessed writable by one object in a given subdomain. More...
virtual const VariableValue &	coupledValueOld (const std::string &var_name, unsigned int comp=0) const
	Returns an old value from previous time step of a coupled variable. More...
std::vector< const VariableValue * >	coupledValuesOld (const std::string &var_name) const
	Returns the old values for all of a coupled variable's components. More...
virtual const VariableValue &	coupledValueOlder (const std::string &var_name, unsigned int comp=0) const
	Returns an old value from two time steps previous of a coupled variable. More...
std::vector< const VariableValue * >	coupledValuesOlder (const std::string &var_name) const
	Returns the older values for all of a coupled variable's components. More...
virtual const VariableValue &	coupledValuePreviousNL (const std::string &var_name, unsigned int comp=0) const
	Returns value of previous Newton iterate of a coupled variable. More...
virtual const VectorVariableValue &	coupledVectorValueOld (const std::string &var_name, unsigned int comp=0) const
	Returns an old value from previous time step of a coupled vector variable. More...
virtual const VectorVariableValue &	coupledVectorValueOlder (const std::string &var_name, unsigned int comp=0) const
	Returns an old value from two time steps previous of a coupled vector variable. More...
virtual const ArrayVariableValue &	coupledArrayValueOld (const std::string &var_name, unsigned int comp=0) const
	Returns an old value from previous time step of a coupled array variable. More...
virtual const ArrayVariableValue &	coupledArrayValueOlder (const std::string &var_name, unsigned int comp=0) const
	Returns an old value from two time steps previous of a coupled array variable. More...
virtual const VariableGradient &	coupledGradient (const std::string &var_name, unsigned int comp=0) const
	Returns gradient of a coupled variable. More...
std::vector< const VariableGradient * >	coupledGradients (const std::string &var_name) const
	Returns the gradients for all of a coupled variable's components. More...
const ADVariableGradient &	adCoupledGradient (const std::string &var_name, unsigned int comp=0) const
	Returns gradient of a coupled variable for use in Automatic Differentiation. More...
const ADVariableGradient &	adCoupledGradientDot (const std::string &var_name, unsigned int comp=0) const
	Returns gradient of a coupled variable's time derivative for use in Automatic Differentiation. More...
std::vector< const ADVariableGradient * >	adCoupledGradients (const std::string &var_name) const
	Returns the gradients for all of a coupled variable's components for use in Automatic Differentiation. More...
template<bool is_ad>
const GenericVariableGradient< is_ad > &	coupledGenericGradient (const std::string &var_name, unsigned int comp=0) const
	Returns gradient of a coupled variable for use in templated automatic differentiation. More...
template<>
const GenericVariableGradient< false > &	coupledGenericGradient (const std::string &var_name, unsigned int comp) const
template<>
const GenericVariableGradient< true > &	coupledGenericGradient (const std::string &var_name, unsigned int comp) const
template<bool is_ad>
std::vector< const GenericVariableGradient< is_ad > * >	coupledGenericGradients (const std::string &var_name) const
	Returns the gradients for all of a coupled variable's components for use in templated automatic differentiation. More...
template<>
std::vector< const GenericVariableGradient< false > * >	coupledGenericGradients (const std::string &var_name) const
template<>
std::vector< const GenericVariableGradient< true > * >	coupledGenericGradients (const std::string &var_name) const
const ADVectorVariableGradient &	adCoupledVectorGradient (const std::string &var_name, unsigned int comp=0) const
	Returns gradient of a coupled vector variable for use in Automatic Differentiation. More...
const ADVariableSecond &	adCoupledSecond (const std::string &var_name, unsigned int comp=0) const
	Returns second derivatives of a coupled variable for use in Automatic Differentiation. More...
const ADVectorVariableSecond &	adCoupledVectorSecond (const std::string &var_name, unsigned int comp=0) const
	Returns second derivatives of a coupled vector variable for use in Automatic Differentiation. More...
virtual const VariableGradient &	coupledGradientOld (const std::string &var_name, unsigned int comp=0) const
	Returns an old gradient from previous time step of a coupled variable. More...
std::vector< const VariableGradient * >	coupledGradientsOld (const std::string &var_name) const
	Returns the old gradients for all of a coupled variable's components. More...
virtual const VariableGradient &	coupledGradientOlder (const std::string &var_name, unsigned int comp=0) const
	Returns an old gradient from two time steps previous of a coupled variable. More...
virtual const VariableGradient &	coupledGradientPreviousNL (const std::string &var_name, unsigned int comp=0) const
	Returns gradient of a coupled variable for previous Newton iterate. More...
virtual const VariableGradient &	coupledGradientDot (const std::string &var_name, unsigned int comp=0) const
	Time derivative of the gradient of a coupled variable. More...
virtual const VariableGradient &	coupledGradientDotDot (const std::string &var_name, unsigned int comp=0) const
	Second time derivative of the gradient of a coupled variable. More...
virtual const VectorVariableGradient &	coupledVectorGradient (const std::string &var_name, unsigned int comp=0) const
	Returns gradient of a coupled vector variable. More...
virtual const VectorVariableGradient &	coupledVectorGradientOld (const std::string &var_name, unsigned int comp=0) const
	Returns an old gradient from previous time step of a coupled vector variable. More...
virtual const VectorVariableGradient &	coupledVectorGradientOlder (const std::string &var_name, unsigned int comp=0) const
	Returns an old gradient from two time steps previous of a coupled vector variable. More...
virtual const ArrayVariableGradient &	coupledArrayGradient (const std::string &var_name, unsigned int comp=0) const
	Returns gradient of a coupled array variable. More...
virtual const ArrayVariableGradient &	coupledArrayGradientOld (const std::string &var_name, unsigned int comp=0) const
	Returns an old gradient from previous time step of a coupled array variable. More...
virtual const ArrayVariableGradient &	coupledArrayGradientOlder (const std::string &var_name, unsigned int comp=0) const
	Returns an old gradient from two time steps previous of a coupled array variable. More...
virtual const ArrayVariableGradient &	coupledArrayGradientDot (const std::string &var_name, unsigned int comp=0) const
	Retun a gradient of a coupled array variable's time derivative. More...
virtual const VectorVariableCurl &	coupledCurl (const std::string &var_name, unsigned int comp=0) const
	Returns curl of a coupled variable. More...
virtual const VectorVariableCurl &	coupledCurlOld (const std::string &var_name, unsigned int comp=0) const
	Returns an old curl from previous time step of a coupled variable. More...
virtual const VectorVariableCurl &	coupledCurlOlder (const std::string &var_name, unsigned int comp=0) const
	Returns an old curl from two time steps previous of a coupled variable. More...
virtual const VariableSecond &	coupledSecond (const std::string &var_name, unsigned int comp=0) const
	Returns second spatial derivatives of a coupled variable. More...
virtual const VariableSecond &	coupledSecondOld (const std::string &var_name, unsigned int comp=0) const
	Returns an old second spatial derivatives from previous time step of a coupled variable. More...
virtual const VariableSecond &	coupledSecondOlder (const std::string &var_name, unsigned int comp=0) const
	Returns an old second derivative from two time steps previous of a coupled variable. More...
virtual const VariableSecond &	coupledSecondPreviousNL (const std::string &var_name, unsigned int comp=0) const
	Returns second derivative of a coupled variable for the previous Newton iterate. More...
virtual const VariableValue &	coupledDot (const std::string &var_name, unsigned int comp=0) const
	Time derivative of a coupled variable. More...
std::vector< const VariableValue * >	coupledDots (const std::string &var_name) const
	Returns the time derivatives for all of a coupled variable's components. More...
virtual const VariableValue &	coupledDotDot (const std::string &var_name, unsigned int comp=0) const
	Second time derivative of a coupled variable. More...
virtual const VariableValue &	coupledDotOld (const std::string &var_name, unsigned int comp=0) const
	Old time derivative of a coupled variable. More...
virtual const VariableValue &	coupledDotDotOld (const std::string &var_name, unsigned int comp=0) const
	Old second time derivative of a coupled variable. More...
const ADVariableValue &	adCoupledDot (const std::string &var_name, unsigned int comp=0) const
	Time derivative of a coupled variable for ad simulations. More...
std::vector< const ADVariableValue * >	adCoupledDots (const std::string &var_name) const
	Returns the time derivatives for all of a coupled variable's components for ad simulations. More...
const ADVariableValue &	adCoupledDotDot (const std::string &var_name, unsigned int comp=0) const
	Second time derivative of a coupled variable for ad simulations. More...
const ADVectorVariableValue &	adCoupledVectorDot (const std::string &var_name, unsigned int comp=0) const
	Time derivative of a vector coupled variable for ad simulations. More...
virtual const VectorVariableValue &	coupledVectorDot (const std::string &var_name, unsigned int comp=0) const
	Time derivative of a coupled vector variable. More...
virtual const VectorVariableValue &	coupledVectorDotDot (const std::string &var_name, unsigned int comp=0) const
	Second time derivative of a coupled vector variable. More...
virtual const VectorVariableValue &	coupledVectorDotOld (const std::string &var_name, unsigned int comp=0) const
	Old time derivative of a coupled vector variable. More...
virtual const VectorVariableValue &	coupledVectorDotDotOld (const std::string &var_name, unsigned int comp=0) const
	Old second time derivative of a coupled vector variable. More...
virtual const VariableValue &	coupledVectorDotDu (const std::string &var_name, unsigned int comp=0) const
	Time derivative of a coupled vector variable with respect to the coefficients. More...
virtual const VariableValue &	coupledVectorDotDotDu (const std::string &var_name, unsigned int comp=0) const
	Second time derivative of a coupled vector variable with respect to the coefficients. More...
virtual const ArrayVariableValue &	coupledArrayDot (const std::string &var_name, unsigned int comp=0) const
	Time derivative of a coupled array variable. More...
virtual const ArrayVariableValue &	coupledArrayDotDot (const std::string &var_name, unsigned int comp=0) const
	Second time derivative of a coupled array variable. More...
virtual const ArrayVariableValue &	coupledArrayDotOld (const std::string &var_name, unsigned int comp=0) const
	Old time derivative of a coupled array variable. More...
virtual const ArrayVariableValue &	coupledArrayDotDotOld (const std::string &var_name, unsigned int comp=0) const
	Old second time derivative of a coupled array variable. More...
virtual const VariableValue &	coupledDotDu (const std::string &var_name, unsigned int comp=0) const
	Time derivative of a coupled variable with respect to the coefficients. More...
virtual const VariableValue &	coupledDotDotDu (const std::string &var_name, unsigned int comp=0) const
	Second time derivative of a coupled variable with respect to the coefficients. More...
const VariableValue &	coupledArrayDotDu (const std::string &var_name, unsigned int comp=0) const
	Time derivative of a coupled array variable with respect to the coefficients. More...
template<typename T >
const T &	coupledNodalValue (const std::string &var_name, unsigned int comp=0) const
	Returns nodal values of a coupled variable. More...
template<typename T >
const Moose::ADType< T >::type &	adCoupledNodalValue (const std::string &var_name, unsigned int comp=0) const
	Returns AD nodal values of a coupled variable. More...
template<typename T >
const T &	coupledNodalValueOld (const std::string &var_name, unsigned int comp=0) const
	Returns an old nodal value from previous time step of a coupled variable. More...
template<typename T >
const T &	coupledNodalValueOlder (const std::string &var_name, unsigned int comp=0) const
	Returns an old nodal value from two time steps previous of a coupled variable. More...
template<typename T >
const T &	coupledNodalValuePreviousNL (const std::string &var_name, unsigned int comp=0) const
	Returns nodal values of a coupled variable for previous Newton iterate. More...
template<typename T >
const T &	coupledNodalDot (const std::string &var_name, unsigned int comp=0) const
	Nodal values of time derivative of a coupled variable. More...
virtual const VariableValue &	coupledNodalDotDot (const std::string &var_name, unsigned int comp=0) const
	Nodal values of second time derivative of a coupled variable. More...
virtual const VariableValue &	coupledNodalDotOld (const std::string &var_name, unsigned int comp=0) const
	Nodal values of old time derivative of a coupled variable. More...
virtual const VariableValue &	coupledNodalDotDotOld (const std::string &var_name, unsigned int comp=0) const
	Nodal values of old second time derivative of a coupled variable. More...
virtual const VariableValue &	coupledDofValues (const std::string &var_name, unsigned int comp=0) const
	Returns DoFs in the current solution vector of a coupled variable for the local element. More...
std::vector< const VariableValue * >	coupledAllDofValues (const std::string &var_name) const
	Returns DoFs in the current solution vector of all of a coupled variable's components for the local element. More...
virtual const VariableValue &	coupledDofValuesOld (const std::string &var_name, unsigned int comp=0) const
	Returns DoFs in the old solution vector of a coupled variable for the local element. More...
std::vector< const VariableValue * >	coupledAllDofValuesOld (const std::string &var_name) const
	Returns DoFs in the old solution vector of all of a coupled variable's components for the local element. More...
virtual const VariableValue &	coupledDofValuesOlder (const std::string &var_name, unsigned int comp=0) const
	Returns DoFs in the older solution vector of a coupled variable for the local element. More...
std::vector< const VariableValue * >	coupledAllDofValuesOlder (const std::string &var_name) const
	Returns DoFs in the older solution vector of all of a coupled variable's components for the local element. More...
virtual const ArrayVariableValue &	coupledArrayDofValues (const std::string &var_name, unsigned int comp=0) const
	Returns DoFs in the current solution vector of a coupled array variable for the local element. More...
virtual const ADVariableValue &	adCoupledDofValues (const std::string &var_name, unsigned int comp=0) const
	Returns DOF value of a coupled variable for use in Automatic Differentiation. More...
const ADVariableValue &	adZeroValue () const
	method that returns _zero to RESIDUAL computing objects and _ad_zero to JACOBIAN computing objects More...
const ADVariableGradient &	adZeroGradient () const
	method that returns _grad_zero to RESIDUAL computing objects and _ad_grad_zero to JACOBIAN computing objects More...
const ADVariableSecond &	adZeroSecond () const
	Retrieve a zero second for automatic differentiation. More...
template<bool is_ad>
const GenericVariableValue< is_ad > &	genericZeroValue ()
	Returns zero value templated with automatic differentiation boolean. More...
template<>
const GenericVariableValue< false > &	genericZeroValue ()
template<>
const GenericVariableValue< true > &	genericZeroValue ()
template<bool is_ad>
const GenericVariableGradient< is_ad > &	genericZeroGradient ()
	Returns zero gradient templated with automatic differentiation boolean. More...
template<>
const GenericVariableGradient< false > &	genericZeroGradient ()
template<>
const GenericVariableGradient< true > &	genericZeroGradient ()
template<bool is_ad>
const GenericVariableSecond< is_ad > &	genericZeroSecond ()
	Returns zero second derivative templated with automatic differentiation boolean. More...
template<>
const GenericVariableSecond< false > &	genericZeroSecond ()
template<>
const GenericVariableSecond< true > &	genericZeroSecond ()
bool	checkVar (const std::string &var_name, unsigned int comp=0, unsigned int comp_bound=0) const
	Check that the right kind of variable is being coupled in. More...
const MooseVariableFieldBase *	getFEVar (const std::string &var_name, unsigned int comp) const
	Deprecated method. More...
const MooseVariableFieldBase *	getFieldVar (const std::string &var_name, unsigned int comp) const
MooseVariableFieldBase *	getFieldVar (const std::string &var_name, unsigned int comp)
template<typename T >
const T *	getVarHelper (const std::string &var_name, unsigned int comp) const
	Helper that that be used to retrieve a variable of arbitrary type T. More...
template<typename T >
T *	getVarHelper (const std::string &var_name, unsigned int comp)
	Helper that can be used to retrieve a variable of arbitrary type T. More...
MooseVariable *	getVar (const std::string &var_name, unsigned int comp)
	Extract pointer to a coupled variable. More...
const MooseVariable *	getVar (const std::string &var_name, unsigned int comp) const
	Extract pointer to a coupled variable. More...
VectorMooseVariable *	getVectorVar (const std::string &var_name, unsigned int comp)
	Extract pointer to a coupled vector variable. More...
const VectorMooseVariable *	getVectorVar (const std::string &var_name, unsigned int comp) const
	Extract pointer to a coupled vector variable. More...
ArrayMooseVariable *	getArrayVar (const std::string &var_name, unsigned int comp)
	Extract pointer to a coupled array variable. More...
const ArrayMooseVariable *	getArrayVar (const std::string &var_name, unsigned int comp) const
	Extract pointer to a coupled array variable. More...
void	validateExecutionerType (const std::string &name, const std::string &fn_name) const
	Checks to make sure that the current Executioner has set "_is_transient" when old/older values are coupled in. More...
template<typename T , typename Func >
std::vector< T >	coupledVectorHelper (const std::string &var_name, const Func &func) const
bool	isCoupledScalar (const std::string &var_name, unsigned int i=0) const
	Returns true if a variables has been coupled_as name. More...
unsigned int	coupledScalarComponents (const std::string &var_name) const
	Return the number of components to the coupled scalar variable. More...
unsigned int	coupledScalar (const std::string &var_name, unsigned int comp=0) const
	Returns the index for a scalar coupled variable by name. More...
Order	coupledScalarOrder (const std::string &var_name, unsigned int comp=0) const
	Returns the order for a scalar coupled variable by name. More...
const VariableValue &	coupledScalarValue (const std::string &var_name, unsigned int comp=0) const
	Returns value of a scalar coupled variable. More...
const ADVariableValue &	adCoupledScalarValue (const std::string &var_name, unsigned int comp=0) const
	Returns AD value of a scalar coupled variable. More...
template<bool is_ad>
const GenericVariableValue< is_ad > &	coupledGenericScalarValue (const std::string &var_name, unsigned int comp=0) const
	Returns value of a coupled scalar variable for use in templated automatic differentiation classes. More...
template<>
const GenericVariableValue< false > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const
template<>
const GenericVariableValue< true > &	coupledGenericScalarValue (const std::string &var_name, const unsigned int comp) const
const VariableValue &	coupledVectorTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const
	Returns value of a scalar coupled variable. More...
const VariableValue &	coupledMatrixTagScalarValue (const std::string &var_name, TagID tag, unsigned int comp=0) const
	Returns value of a scalar coupled variable. More...
const VariableValue &	coupledScalarValueOld (const std::string &var_name, unsigned int comp=0) const
	Returns the old (previous time step) value of a scalar coupled variable. More...
const VariableValue &	coupledScalarValueOlder (const std::string &var_name, unsigned int comp=0) const
	Returns the older (two time steps previous) value of a scalar coupled variable. More...
const VariableValue &	coupledScalarDot (const std::string &var_name, unsigned int comp=0) const
	Returns the time derivative of a scalar coupled variable. More...
const ADVariableValue &	adCoupledScalarDot (const std::string &var_name, unsigned int comp=0) const
	Returns the time derivative of a scalar coupled variable, including its dependence on the nonlinear degrees of freedom through automatic differentiation. More...
const VariableValue &	coupledScalarDotDot (const std::string &var_name, unsigned int comp=0) const
	Returns the second time derivative of a scalar coupled variable. More...
const VariableValue &	coupledScalarDotOld (const std::string &var_name, unsigned int comp=0) const
	Returns the old time derivative of a scalar coupled variable. More...
const VariableValue &	coupledScalarDotDotOld (const std::string &var_name, unsigned int comp=0) const
	Returns the old second time derivative of a scalar coupled variable. More...
const VariableValue &	coupledScalarDotDu (const std::string &var_name, unsigned int comp=0) const
	Time derivative of a scalar coupled variable with respect to the coefficients. More...
const VariableValue &	coupledScalarDotDotDu (const std::string &var_name, unsigned int comp=0) const
	Second time derivative of a scalar coupled variable with respect to the coefficients. More...
const MooseVariableScalar *	getScalarVar (const std::string &var_name, unsigned int comp) const
	Extract pointer to a scalar coupled variable. More...
void	addMooseVariableDependency (MooseVariableFieldBase *var)
	Call this function to add the passed in MooseVariableFieldBase as a variable that this object depends on. More...
void	addMooseVariableDependency (const std::vector< MooseVariableFieldBase *> &vars)

Protected Attributes
bool	_neighbor_nodal
const InputParameters &	_c_parameters
const std::string &	_c_name
	The name of the object this interface is part of. More...
const std::string &	_c_type
	The type of the object this interface is part of. More...
FEProblemBase &	_c_fe_problem
const SystemBase *const	_c_sys
	Pointer to the system object if the moose object this is an interface for has one. More...
std::unordered_map< std::string, std::vector< MooseVariableFieldBase * > >	_coupled_vars
	Coupled vars whose values we provide. More...
std::vector< MooseVariableFieldBase * >	_coupled_moose_vars
	Vector of all coupled variables. More...
std::vector< MooseVariable * >	_coupled_standard_moose_vars
	Vector of standard coupled variables. More...
std::vector< VectorMooseVariable * >	_coupled_vector_moose_vars
	Vector of vector coupled variables. More...
std::vector< ArrayMooseVariable * >	_coupled_array_moose_vars
	Vector of array coupled variables. More...
std::vector< MooseVariableFV< Real > * >	_coupled_standard_fv_moose_vars
	Vector of standard finite volume coupled variables. More...
std::vector< MooseLinearVariableFV< Real > * >	_coupled_standard_linear_fv_moose_vars
	Vector of standard linear finite volume coupled variables. More...
const std::unordered_map< std::string, std::string > &	_new_to_deprecated_coupled_vars
	map from new to deprecated variable names More...
bool	_c_nodal
	True if we provide coupling to nodal values. More...
bool	_c_is_implicit
	True if implicit value is required. More...
const bool	_c_allow_element_to_nodal_coupling
THREAD_ID	_c_tid
	Thread ID of the thread using this object. More...
std::unordered_map< std::string, std::vector< std::unique_ptr< VariableValue > > >	_default_value
	Will hold the default value for optional coupled variables. More...
std::unordered_map< std::string, std::unique_ptr< MooseArray< DualReal > > >	_ad_default_value
	Will hold the default value for optional coupled variables for automatic differentiation. More...
std::unordered_map< std::string, std::unique_ptr< VectorVariableValue > >	_default_vector_value
	Will hold the default value for optional vector coupled variables. More...
std::unordered_map< std::string, std::unique_ptr< ArrayVariableValue > >	_default_array_value
	Will hold the default value for optional array coupled variables. More...
std::unordered_map< std::string, std::unique_ptr< MooseArray< ADRealVectorValue > > >	_ad_default_vector_value
	Will hold the default value for optional vector coupled variables for automatic differentiation. More...
VariableValue	_default_value_zero
	This will always be zero because the default values for optionally coupled variables is always constant and this is used for time derivative info. More...
VariableGradient	_default_gradient
	This will always be zero because the default values for optionally coupled variables is always constant. More...
MooseArray< ADRealVectorValue >	_ad_default_gradient
	This will always be zero because the default values for optionally coupled variables is always constant. More...
MooseArray< ADRealTensorValue >	_ad_default_vector_gradient
	This will always be zero because the default values for optionally coupled vector variables is always constant. More...
VariableSecond	_default_second
	This will always be zero because the default values for optionally coupled variables is always constant. More...
MooseArray< ADRealTensorValue >	_ad_default_second
	This will always be zero because the default values for optionally coupled variables is always constant. More...
const VariableValue &	_zero
	Zero value of a variable. More...
const VariablePhiValue &	_phi_zero
const MooseArray< DualReal > &	_ad_zero
const VariableGradient &	_grad_zero
	Zero gradient of a variable. More...
const MooseArray< ADRealVectorValue > &	_ad_grad_zero
const VariablePhiGradient &	_grad_phi_zero
	Zero gradient of trial function. More...
const VariableSecond &	_second_zero
	Zero second derivative of a variable. More...
const MooseArray< ADRealTensorValue > &	_ad_second_zero
const VariablePhiSecond &	_second_phi_zero
	Zero second derivative of a test function. More...
const VectorVariableValue &	_vector_zero
	Zero value of a vector variable. More...
const VectorVariableCurl &	_vector_curl_zero
	Zero value of the curl of a vector variable. More...
VectorVariableValue	_default_vector_value_zero
	This will always be zero because the default values for optionally coupled variables is always constant and this is used for time derivative info. More...
VectorVariableGradient	_default_vector_gradient
	This will always be zero because the default values for optionally coupled variables is always constant. More...
VectorVariableCurl	_default_vector_curl
	This will always be zero because the default values for optionally coupled variables is always constant. More...
ArrayVariableValue	_default_array_value_zero
	This will always be zero because the default values for optionally coupled variables is always constant and this is used for time derivative info. More...
ArrayVariableGradient	_default_array_gradient
	This will always be zero because the default values for optionally coupled variables is always constant. More...
ArrayVariableCurl	_default_array_curl
	This will always be zero because the default values for optionally coupled variables is always constant. More...
bool	_coupleable_neighbor
	Whether or not this object is a "neighbor" object: ie all of it's coupled values should be neighbor values. More...
FEProblemBase &	_sc_fe_problem
const THREAD_ID	_sc_tid
	Thread ID of the thread using this object. More...
const Real &	_real_zero
	Scalar zero. More...
const VariableValue &	_scalar_zero
	Zero value of a scalar variable. More...
const Point &	_point_zero
	Zero point. More...

Detailed Description

Intermediate base class that ties together all the interfaces for getting MooseVariables with the MooseVariableDependencyInterface.

Definition at line 22 of file NeighborCoupleableMooseVariableDependencyIntermediateInterface.h.

Constructor & Destructor Documentation

NeighborCoupleableMooseVariableDependencyIntermediateInterface()

NeighborCoupleableMooseVariableDependencyIntermediateInterface::NeighborCoupleableMooseVariableDependencyIntermediateInterface ( const MooseObject *  moose_object, bool  nodal, bool  neighbor_nodal, bool  is_fv = false  )

inline

Definition at line 30 of file NeighborCoupleableMooseVariableDependencyIntermediateInterface.h.

    : NeighborCoupleable(moose_object, nodal, neighbor_nodal, is_fv),
      ScalarCoupleable(moose_object),
      MooseVariableDependencyInterface(moose_object)
  {
    for (MooseVariableFEBase * coupled_var : getCoupledMooseVars())
      addMooseVariableDependency(coupled_var);
  }

Member Function Documentation

adCoupledDofValues()

const ADVariableValue & Coupleable::adCoupledDofValues ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns DOF value of a coupled variable for use in Automatic Differentiation.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to an ADVariableValue for the DoFs of the coupled variable

Definition at line 2004 of file Coupleable.C.

{
  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);

  if (!var)
    return *getADDefaultValue(var_name);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  if (!_c_is_implicit)
    mooseError("Not implemented");

  if (!_coupleable_neighbor)
    return var->adDofValues();
  return var->adDofValuesNeighbor();
}

adCoupledDot()

const ADVariableValue & Coupleable::adCoupledDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Time derivative of a coupled variable for ad simulations.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the time derivative of the coupled variable

See also

Kernel::dot

Definition at line 2154 of file Coupleable.C.

Referenced by Coupleable::adCoupledDots().

{
  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);

  if (!var)
    return *getADDefaultValue(var_name);
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (_c_nodal)
    mooseError("Not implemented");

  if (!_coupleable_neighbor)
    return var->adUDot();
  return var->adUDotNeighbor();
}

adCoupledDotDot()

const ADVariableValue & Coupleable::adCoupledDotDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Second time derivative of a coupled variable for ad simulations.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to an ADVariableValue containing the second time derivative of the coupled variable

Definition at line 2171 of file Coupleable.C.

{
  const auto * const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);

  if (!var)
    return *getADDefaultValue(var_name);
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (_c_nodal)
    mooseError("Not implemented");

  if (!_coupleable_neighbor)
    return var->adUDotDot();
  return var->adUDotDotNeighbor();
}

adCoupledDots()

std::vector< const ADVariableValue * > Coupleable::adCoupledDots ( const std::string &  var_name ) const

protectedinherited

Returns the time derivatives for all of a coupled variable's components for ad simulations.

Parameters

var_name

Name of coupled variable

Returns

Vector of VariableValue pointers for each component of var_name

Definition at line 2636 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &adCoupledDot(var_name, comp); };
  return coupledVectorHelper<const ADVariableValue *>(var_name, func);
}

adCoupledGradient()

const ADVariableGradient & Coupleable::adCoupledGradient ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns gradient of a coupled variable for use in Automatic Differentiation.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to an ADVariableGradient containing the gradient of the coupled variable

See also

Kernel::gradient

Definition at line 2095 of file Coupleable.C.

Referenced by Coupleable::adCoupledGradients().

{
  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);

  if (!var)
    return getADDefaultGradient();
  checkFuncType(var_name, VarType::Gradient, FuncAge::Curr);

  if (!_c_is_implicit)
    mooseError("Not implemented");

  if (!_coupleable_neighbor)
    return var->adGradSln();
  return var->adGradSlnNeighbor();
}

adCoupledGradientDot()

const ADVariableGradient & Coupleable::adCoupledGradientDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns gradient of a coupled variable's time derivative for use in Automatic Differentiation.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to an ADVariableGradient containing the gradient of the coupled variable's time derivative

Definition at line 2112 of file Coupleable.C.

{
  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);

  if (!var)
    return getADDefaultGradient();
  checkFuncType(var_name, VarType::GradientDot, FuncAge::Curr);

  if (!_c_is_implicit)
    mooseError("Not implemented");

  if (!_coupleable_neighbor)
    return var->adGradSlnDot();
  return var->adGradSlnNeighborDot();
}

adCoupledGradients()

std::vector< const ADVariableGradient * > Coupleable::adCoupledGradients ( const std::string &  var_name ) const

protectedinherited

Returns the gradients for all of a coupled variable's components for use in Automatic Differentiation.

Parameters

var_name

Name of coupled variable

Returns

Vector of ADVariableGradient pointers for each component of var_name

Definition at line 2615 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &adCoupledGradient(var_name, comp); };
  return coupledVectorHelper<const ADVariableGradient *>(var_name, func);
}

adCoupledLowerValue()

const ADVariableValue & Coupleable::adCoupledLowerValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns value of a coupled lower-dimensional variable for use in Automatic Differentiation.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a ADVariableValue for the coupled variable

Definition at line 2077 of file Coupleable.C.

{
  auto var = getVarHelper<MooseVariableFE<Real>>(var_name, comp);

  if (!var)
    return *getADDefaultValue(var_name);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  if (!_c_is_implicit)
    mooseError("adCoupledLowerValue cannot be called in a coupleable neighbor object");

  if (_c_nodal)
    return var->adDofValues();
  else
    return var->adSlnLower();
}

adCoupledNeighborGradient()

const ADVariableGradient & NeighborCoupleable::adCoupledNeighborGradient ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Get the coupled neighbor variable gradient for var_name with derivative information for automatic differentiation objects.

Definition at line 224 of file NeighborCoupleable.C.

Referenced by NeighborCoupleable::coupledGenericNeighborGradient().

{
  if (_neighbor_nodal)
    mooseError("Nodal variables do not have gradients");
  if (!_c_is_implicit)
    mooseError(
        "adCoupledNeighborGradient returns a data structure with derivatives. Explicit schemes "
        "use old solution data which do not have derivatives so adCoupledNeighborGradient is "
        "not appropriate. Please use coupledNeighborGradient instead");

  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
  return var->adGradSlnNeighbor();
}

adCoupledNeighborValue()

const ADVariableValue & NeighborCoupleable::adCoupledNeighborValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Get the coupled neighbor variable value for var_name with derivative information for automatic differentiation objects.

Definition at line 61 of file NeighborCoupleable.C.

Referenced by NeighborCoupleable::adCoupledNeighborValues(), and NeighborCoupleable::coupledGenericNeighborValue().

{
  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);

  if (!var)
    return *getADDefaultValue(var_name);

  if (_neighbor_nodal)
    mooseError("adCoupledNeighborValue cannot be used for nodal compute objects at this time");
  if (!_c_is_implicit)
    mooseError("adCoupledNeighborValue returns a data structure with derivatives. Explicit schemes "
               "use old solution data which do not have derivatives so adCoupledNeighborValue is "
               "not appropriate. Please use coupledNeighborValue instead");

  return var->adSlnNeighbor();
}

adCoupledNeighborValueDot()

const ADVariableValue & NeighborCoupleable::adCoupledNeighborValueDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Get the time derivative of the coupled neighbor variable value for var_name with derivative information for automatic differentiation objects.

Definition at line 79 of file NeighborCoupleable.C.

{
  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);

  if (!_c_is_implicit)
    mooseError(
        "adCoupledNeighborValueDot returns a data structure with derivatives. Explicit schemes "
        "use old solution data which do not have derivatives so adCoupledNeighborValueDot is "
        "not appropriate. Please use coupledNeighborValueDot instead");

  if (_neighbor_nodal)
    mooseError("adCoupledNeighborValueDot cannot be used for nodal compute objects at this time");
  else
    return var->adUDotNeighbor();
}

adCoupledNeighborValues()

std::vector< const ADVariableValue * > NeighborCoupleable::adCoupledNeighborValues ( const std::string &  var_name ) const

inherited

Definition at line 96 of file NeighborCoupleable.C.

{
  auto func = [this, &var_name](unsigned int comp)
  { return &adCoupledNeighborValue(var_name, comp); };
  return coupledVectorHelper<const ADVariableValue *>(var_name, func);
}

adCoupledNodalValue()

template<typename T >

template const ADRealVectorValue & Coupleable::adCoupledNodalValue< RealVectorValue > ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns AD nodal values of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

Definition at line 2035 of file Coupleable.C.

{
  static const typename Moose::ADType<T>::type zero = 0;
  if (!isCoupled(var_name))
    return zero;

  if (!_c_nodal)
    mooseError("The adCoupledNodalValue method should only be called for nodal computing objects");
  if (_coupleable_neighbor)
    mooseError(
        "The adCoupledNodalValue method shouldn't be called for neighbor computing objects. I "
        "don't even know what that would mean, although maybe someone could explain it to me.");
  if (!_c_is_implicit)
    mooseError("If you're going to use an explicit scheme, then use coupledNodalValue instead of "
               "adCoupledNodalValue");

  const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);

  return var->adNodalValue();
}

adCoupledScalarDot()

const ADVariableValue & ScalarCoupleable::adCoupledScalarDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns the time derivative of a scalar coupled variable, including its dependence on the nonlinear degrees of freedom through automatic differentiation.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to the time derivative at quadrature points for the coupled variable, including automatic differentiation information

Definition at line 252 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "adCoupledScalarDot");
  return getScalarVar(var_name, comp)->adUDot();
}

adCoupledScalarValue()

const ADVariableValue & ScalarCoupleable::adCoupledScalarValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns AD value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a ADVariableValue for the coupled variable

Definition at line 135 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return *getADDefaultValue(var_name);

  auto var = getScalarVar(var_name, comp);

  if (_sc_is_implicit)
    return var->adSln();
  else
    mooseError("adCoupledValue for non-implicit calculations is not currently supported. Use "
               "coupledValue instead for non-implicit");
}

adCoupledSecond()

const ADVariableSecond & Coupleable::adCoupledSecond ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns second derivatives of a coupled variable for use in Automatic Differentiation.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableSecond containing the second derivatives of the coupled variable

Definition at line 2129 of file Coupleable.C.

{
  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);

  if (!var)
    return getADDefaultSecond();
  checkFuncType(var_name, VarType::Second, FuncAge::Curr);

  if (!_c_is_implicit)
    mooseError("Not implemented");

  if (!_coupleable_neighbor)
    return var->adSecondSln();
  else
    return var->adSecondSlnNeighbor();
}

adCoupledValue()

const ADVariableValue & Coupleable::adCoupledValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns value of a coupled variable for use in Automatic Differentiation.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a ADVariableValue for the coupled variable

Definition at line 2057 of file Coupleable.C.

Referenced by Coupleable::adCoupledValues().

{
  const auto * const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);

  if (!var)
    return *getADDefaultValue(var_name);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  if (!_c_is_implicit)
    mooseError("Not implemented");

  if (_c_nodal)
    return var->adDofValues();

  if (!_coupleable_neighbor)
    return var->adSln();
  return var->adSlnNeighbor();
}

adCoupledValues()

std::vector< const ADVariableValue * > Coupleable::adCoupledValues ( const std::string &  var_name ) const

protectedinherited

Returns the values for all of a coupled variable's components for use in Automatic Differentiation.

Parameters

var_name

Name of coupled variable

Returns

Vector of ADVariableValue pointers for each component of var_name

Definition at line 2426 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &adCoupledValue(var_name, comp); };
  return coupledVectorHelper<const ADVariableValue *>(var_name, func);
}

adCoupledVectorDot()

const ADVectorVariableValue & Coupleable::adCoupledVectorDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Time derivative of a vector coupled variable for ad simulations.

Parameters

var_name	Name of vector coupled variable
comp	Component number

Returns

Reference to a VectorVariableValue containing the time derivative of the coupled variable

See also

Kernel::dot

Definition at line 2188 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
    return *getADDefaultVectorValue(var_name);
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (_c_nodal)
    mooseError("Not implemented");

  if (!_coupleable_neighbor)
    return var->adUDot();
  return var->adUDotNeighbor();
}

adCoupledVectorGradient()

const ADVectorVariableGradient & Coupleable::adCoupledVectorGradient ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns gradient of a coupled vector variable for use in Automatic Differentiation.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a VectorVariableGradient containing the gradient of the coupled variable

See also

Kernel::gradient

Definition at line 2222 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
    return getADDefaultVectorGradient();
  checkFuncType(var_name, VarType::Gradient, FuncAge::Curr);

  if (!_c_is_implicit)
    mooseError("Not implemented");

  if (!_coupleable_neighbor)
    return var->adGradSln();
  return var->adGradSlnNeighbor();
}

adCoupledVectorNeighborValue()

const ADVectorVariableValue & NeighborCoupleable::adCoupledVectorNeighborValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Get the coupled neighbor vector variable value for var_name with derivative information for automatic differentiation objects.

Definition at line 104 of file NeighborCoupleable.C.

{
  auto var = getVarHelper<MooseVariableField<RealVectorValue>>(var_name, comp);

  if (!var)
    return *getADDefaultVectorValue(var_name);

  if (_neighbor_nodal)
    mooseError(
        "adCoupledVectorNeighborValue cannot be used for nodal compute objects at this time");
  if (!_c_is_implicit)
    mooseError(
        "adCoupledVectorNeighborValue returns a data structure with derivatives. Explicit schemes "
        "use old solution data which do not have derivatives so adCoupledVectorNeighborValue is "
        "not appropriate. Please use coupledNeighborValue instead");

  return var->adSlnNeighbor();
}

adCoupledVectorSecond()

const ADVectorVariableSecond& Coupleable::adCoupledVectorSecond ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns second derivatives of a coupled vector variable for use in Automatic Differentiation.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a VectorVariableSecond containing the second derivatives of the coupled variable

adCoupledVectorValue()

const ADVectorVariableValue & Coupleable::adCoupledVectorValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns value of a coupled vector variable for use in Automatic Differentiation.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

See also

Kernel::value

Definition at line 2204 of file Coupleable.C.

Referenced by Coupleable::adCoupledVectorValues().

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
    return *getADDefaultVectorValue(var_name);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  if (_c_nodal)
    mooseError("Not implemented");
  if (!_c_is_implicit)
    mooseError("Not implemented");

  if (!_coupleable_neighbor)
    return var->adSln();
  return var->adSlnNeighbor();
}

adCoupledVectorValues()

std::vector< const ADVectorVariableValue * > Coupleable::adCoupledVectorValues ( const std::string &  var_name ) const

protectedinherited

Returns the values for all of a coupled vector variable's components for use in Automatic Differentiation.

Parameters

var_name

Name of coupled variable

Returns

Vector of ADVariableValue pointers for each component of var_name

Definition at line 2433 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp)
  { return &adCoupledVectorValue(var_name, comp); };
  return coupledVectorHelper<const ADVectorVariableValue *>(var_name, func);
}

addFEVariableCoupleableMatrixTag()

void Coupleable::addFEVariableCoupleableMatrixTag ( TagID  tag )

inlineinherited

Definition at line 104 of file Coupleable.h.

Referenced by Coupleable::coupledMatrixTagValue().

{ _fe_coupleable_matrix_tags.insert(tag); }

addFEVariableCoupleableVectorTag()

void Coupleable::addFEVariableCoupleableVectorTag ( TagID  tag )

inlineinherited

Definition at line 102 of file Coupleable.h.

Referenced by Coupleable::coupledVectorTagArrayGradient(), Coupleable::coupledVectorTagGradient(), Coupleable::vectorTagDofValueHelper(), and Coupleable::vectorTagValueHelper().

{ _fe_coupleable_vector_tags.insert(tag); }

addMooseVariableDependency() [1/2]

void MooseVariableDependencyInterface::addMooseVariableDependency ( MooseVariableFieldBase *  var )

inlineprotectedinherited

Call this function to add the passed in MooseVariableFieldBase as a variable that this object depends on.

Definition at line 73 of file MooseVariableDependencyInterface.h.

Referenced by ADDGKernel::ADDGKernel(), ADIntegratedBCTempl< T >::ADIntegratedBCTempl(), ADInterfaceKernelTempl< T >::ADInterfaceKernelTempl(), ADKernelTempl< T >::ADKernelTempl(), ArrayDGKernel::ArrayDGKernel(), ArrayIntegratedBC::ArrayIntegratedBC(), ArrayKernel::ArrayKernel(), ArrayNodalBC::ArrayNodalBC(), AuxKernelTempl< Real >::AuxKernelTempl(), AuxNodalScalarKernel::AuxNodalScalarKernel(), CoupleableMooseVariableDependencyIntermediateInterface::CoupleableMooseVariableDependencyIntermediateInterface(), DGKernel::DGKernel(), DiracKernelTempl< T >::DiracKernelTempl(), DomainUserObject::DomainUserObject(), ElemElemConstraint::ElemElemConstraint(), ElementIndicator::ElementIndicator(), ElementIntegralArrayVariablePostprocessor::ElementIntegralArrayVariablePostprocessor(), ElementIntegralVariablePostprocessor::ElementIntegralVariablePostprocessor(), ElementIntegralVariableUserObject::ElementIntegralVariableUserObject(), ElementUserObject::ElementUserObject(), ElementVariablePostprocessor::ElementVariablePostprocessor(), FVBoundaryCondition::FVBoundaryCondition(), FVElementalKernel::FVElementalKernel(), FVInterfaceKernel::FVInterfaceKernel(), IntegratedBC::IntegratedBC(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), InterfaceKernelTempl< T >::InterfaceKernelTempl(), InterfaceMaterial::InterfaceMaterial(), InterfaceUserObjectBase::InterfaceUserObjectBase(), InternalSideIndicator::InternalSideIndicator(), InternalSideIntegralVariablePostprocessor::InternalSideIntegralVariablePostprocessor(), InternalSideUserObject::InternalSideUserObject(), Kernel::Kernel(), LinearFVBoundaryCondition::LinearFVBoundaryCondition(), LinearFVKernel::LinearFVKernel(), Marker::Marker(), Material::Material(), MortarConstraintBase::MortarConstraintBase(), NeighborCoupleableMooseVariableDependencyIntermediateInterface(), NodalBC::NodalBC(), NodalConstraint::NodalConstraint(), NodalKernel::NodalKernel(), NodalScalarKernel::NodalScalarKernel(), NodalUserObject::NodalUserObject(), NodeElemConstraint::NodeElemConstraint(), NodeFaceConstraint::NodeFaceConstraint(), PointVariableSamplerBase::PointVariableSamplerBase(), QuadraturePointMarker::QuadraturePointMarker(), SideIntegralVariablePostprocessor::SideIntegralVariablePostprocessor(), SideIntegralVariableUserObject::SideIntegralVariableUserObject(), SideUserObject::SideUserObject(), SideVariablePostprocessor::SideVariablePostprocessor(), VectorIntegratedBC::VectorIntegratedBC(), VectorKernel::VectorKernel(), and VectorNodalBC::VectorNodalBC().

  {
    _moose_variable_dependencies.insert(var);
  }

addMooseVariableDependency() [2/2]

void MooseVariableDependencyInterface::addMooseVariableDependency ( const std::vector< MooseVariableFieldBase *> &  vars )

inlineprotectedinherited

Definition at line 77 of file MooseVariableDependencyInterface.h.

  {
    _moose_variable_dependencies.insert(vars.begin(), vars.end());
  }

adZeroGradient()

const ADVariableGradient & Coupleable::adZeroGradient ( ) const

protectedinherited

method that returns _grad_zero to RESIDUAL computing objects and _ad_grad_zero to JACOBIAN computing objects

Definition at line 2297 of file Coupleable.C.

{
  mooseDeprecated("Method adZeroGradient() is deprecated. Use '_ad_grad_zero' instead.");
  return _ad_grad_zero;
}

adZeroSecond()

const ADVariableSecond & Coupleable::adZeroSecond ( ) const

protectedinherited

Retrieve a zero second for automatic differentiation.

Definition at line 2304 of file Coupleable.C.

{
  mooseDeprecated("Method adZeroSecond() is deprecated. Use '_ad_second_zero' instead.");
  return _ad_second_zero;
}

adZeroValue()

const ADVariableValue & Coupleable::adZeroValue ( ) const

protectedinherited

method that returns _zero to RESIDUAL computing objects and _ad_zero to JACOBIAN computing objects

Definition at line 2290 of file Coupleable.C.

{
  mooseDeprecated("Method adZeroValue() is deprecated. Use '_ad_zero' instead.");
  return _ad_zero;
}

checkAllVariables()

template<typename DofObjectType >

std::set< MooseVariableFieldBase * > MooseVariableDependencyInterface::checkAllVariables ( const DofObjectType &  dof_object, const std::set< MooseVariableFieldBase *> &  vars_to_omit = {}  )

inherited

Check whether all of the variable dependencies have degree of freedom indices on the supplied degree of freedom object.

Parameters

dof_object	The degree of freedom object (an element or node) that we want to check for existence of variable degrees of freedom on
vars_to_omit	Variables that we can omit from checking

Returns

Any variables that do not have degrees of freedom on the supplied degree of freedom object

Definition at line 91 of file MooseVariableDependencyInterface.h.

{
  if (vars_to_omit.empty())
    return checkVariables(dof_object, _moose_variable_dependencies);

  std::set<MooseVariableFieldBase *> vars_to_check;
  std::set_difference(_moose_variable_dependencies.begin(),
                      _moose_variable_dependencies.end(),
                      vars_to_omit.begin(),
                      vars_to_omit.end(),
                      std::inserter(vars_to_check, vars_to_check.begin()));
  return checkVariables(dof_object, vars_to_check);
}

checkVar()

bool Coupleable::checkVar ( const std::string &  var_name, unsigned int  comp = 0, unsigned int  comp_bound = 0  ) const

protectedinherited

Check that the right kind of variable is being coupled in.

Parameters

var_name

The name of the coupled variable

Definition at line 208 of file Coupleable.C.

Referenced by Coupleable::getVarHelper().

{
  const auto var_name = _c_parameters.checkForRename(var_name_in);
  auto it = _c_coupled_scalar_vars.find(var_name);
  if (it != _c_coupled_scalar_vars.end())
  {
    std::string cvars;
    for (auto jt : it->second)
      cvars += " " + jt->name();

    _obj->paramError(var_name,
                     "cannot couple '",
                     var_name,
                     "' to a scalar variable (",
                     cvars,
                     ") where field variable is expected");
  }

  if (!isCoupled(var_name, comp))
    return false; // return false since variable is *not* coupled

  auto vars_vector_it = _coupled_vars.find(var_name);
  if (vars_vector_it == _coupled_vars.end())
    mooseError(_c_name, ": Trying to get a coupled var ", var_name, " that doesn't exist");

  const auto & vars_vector = vars_vector_it->second;

  auto bound = comp_bound ? comp_bound : vars_vector.size();
  checkComponent(_obj, comp, bound, var_name);

  // We should know we have a variable now
  const auto * var = vars_vector[comp];
  if (!var)
    mooseError(
        _c_name,
        ": We did all our checks for the existence of a var, yet we still don't have a var!?");

  // Only perform the following checks for objects that feed into residuals/Jacobians, e.g. objects
  // that inherit from the TaggingInterface
  if (_c_parameters.have_parameter<MultiMooseEnum>("vector_tags"))
  {
    // Are we attempting to couple to a non-FV var in an FV object?
    if (!var->isFV() && _is_fv)
      mooseError("Attempting to couple non-FV variable ",
                 var->name(),
                 " into an FV object ",
                 _c_name,
                 ". This is not currently supported");
  }

  if (!(vars_vector[comp])->isNodal() && _c_nodal && !_c_allow_element_to_nodal_coupling)
    mooseError(_c_name, ": cannot couple elemental variables into nodal objects");

  return true;
}

checkVariables()

template<typename DofObjectType >

template std::set< MooseVariableFieldBase * > MooseVariableDependencyInterface::checkVariables ( const DofObjectType &  dof_object, const std::set< MooseVariableFieldBase *> &  vars_to_check  )

inherited

Check whether all of the supplied variables have degree of freedom indices on the supplied degree of freedom object.

Parameters

dof_object	The degree of freedom object (an element or node) that we want to check for existence of variable degrees of freedom on
vars_to_check	the variables to check

Returns

Any variables that do not have degrees of freedom on the supplied degree of freedom object

Definition at line 25 of file MooseVariableDependencyInterface.C.

Referenced by MooseVariableDependencyInterface::checkAllVariables().

{
  std::set<MooseVariableFieldBase *> vars_without_indices;
  for (auto * const var : vars_to_check)
  {
    var->sys().dofMap().dof_indices(&dof_object, _dof_indices, var->number());
    if (_dof_indices.empty())
      vars_without_indices.insert(var);
  }

  return vars_without_indices;
}

checkWritableVar()

void Coupleable::checkWritableVar ( MooseWritableVariable *  var )

protectedinherited

Checks that the passed in variable is only accessed writable by one object in a given subdomain.

Definition at line 936 of file Coupleable.C.

Referenced by Coupleable::writableCoupledValue(), and Coupleable::writableVariable().

{
  // check domain restrictions for compatibility
  const auto * br = dynamic_cast<const BlockRestrictable *>(this);
  const auto * nfc = dynamic_cast<const NodeFaceConstraint *>(this);

  if (br && !var->hasBlocks(br->blockIDs()))
    mooseError("The variable '",
               var->name(),
               "' must be defined on all blocks '",
               _obj->name(),
               "' is defined on.");

  if (nfc && !var->hasBlocks(nfc->getSecondaryConnectedBlocks()))
    mooseError("The variable '",
               var->name(),
               " must be defined on all blocks '",
               _obj->name(),
               "'s secondary surface is defined on.");

  // make sure only one object can access a variable
  for (const auto & ci : _obj->getMooseApp().getInterfaceObjects<Coupleable>())
    if (ci != this && ci->_writable_coupled_variables[_c_tid].count(var))
    {
      // if both this and ci are block restrictable then we check if the block restrictions
      // are not overlapping. If they don't we permit the call.
      const auto * br_other = dynamic_cast<const BlockRestrictable *>(ci);
      if (br && br_other && br->blockRestricted() && br_other->blockRestricted() &&
          !MooseUtils::setsIntersect(br->blockIDs(), br_other->blockIDs()))
        continue;
      else if (nfc)
        continue;

      mooseError("'",
                 ci->_obj->name(),
                 "' already obtained a writable reference to '",
                 var->name(),
                 "'. Only one object can obtain such a reference per variable and subdomain in a "
                 "simulation.");
    }

  // var is unique across threads, so we could forego having a separate set per thread, but we
  // need quick access to the list of all variables that need to be inserted into the solution
  // vector by a given thread.

  _writable_coupled_variables[_c_tid].insert(var);
}

coupled()

unsigned int Coupleable::coupled ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns the index for a coupled variable by name.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Index of coupled variable, if this is an optionally coupled variable that wasn't provided this will return a unique "invalid" index.

Reimplemented in ShapeUserObject< ElementUserObject >, and ShapeUserObject< SideUserObject >.

Definition at line 441 of file Coupleable.C.

Referenced by Coupleable::coupledIndices(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), and KernelBase::KernelBase().

{
  const auto * var = getFieldVar(var_name, comp);
  if (!var)
  {
    mooseAssert(_optional_var_index.find(var_name) != _optional_var_index.end(),
                "optional var index for " << var_name << " does not exist!");
    // make sure we don't try to access default var ids that were not provided
    checkComponent(_obj, comp, _optional_var_index.at(var_name).size(), var_name);
    return _optional_var_index.at(var_name)[comp];
  }
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  if (var->kind() == Moose::VAR_SOLVER &&
      // are we not an object that feeds into the nonlinear system?
      (!_c_sys || _c_sys->varKind() != Moose::VAR_SOLVER ||
       // are we an object that impacts the nonlinear system and this variable is within our
       // nonlinear system?
       var->sys().number() == _c_sys->number()))
    return var->number();
  else
    // Avoid registering coupling to variables outside of our system (e.g. avoid potentially
    // creating bad Jacobians)
    return std::numeric_limits<unsigned int>::max() - var->number();
}

coupledAllDofValues()

std::vector< const VariableValue * > Coupleable::coupledAllDofValues ( const std::string &  var_name ) const

protectedinherited

Returns DoFs in the current solution vector of all of a coupled variable's components for the local element.

Parameters

var_name

Name of coupled variable

Returns

Vector of VariableValue pointers for each component of the coupled variable

Definition at line 1943 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &coupledDofValues(var_name, comp); };
  return coupledVectorHelper<const VariableValue *>(var_name, func);
}

coupledAllDofValuesOld()

std::vector< const VariableValue * > Coupleable::coupledAllDofValuesOld ( const std::string &  var_name ) const

protectedinherited

Returns DoFs in the old solution vector of all of a coupled variable's components for the local element.

Parameters

var_name

Name of coupled variable

Returns

Vector of VariableValue pointers for each compontnet of the coupled variable

Definition at line 1963 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &coupledDofValuesOld(var_name, comp); };
  return coupledVectorHelper<const VariableValue *>(var_name, func);
}

coupledAllDofValuesOlder()

std::vector< const VariableValue * > Coupleable::coupledAllDofValuesOlder ( const std::string &  var_name ) const

protectedinherited

Returns DoFs in the older solution vector of all of a coupled variable's components for the local element.

Parameters

var_name

Name of coupled variable

Returns

Vector of VariableValue pointers for each component of the coupled variable

Definition at line 1983 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp)
  { return &coupledDofValuesOlder(var_name, comp); };
  return coupledVectorHelper<const VariableValue *>(var_name, func);
}

coupledArrayDofValues()

const ArrayVariableValue & Coupleable::coupledArrayDofValues ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns DoFs in the current solution vector of a coupled array variable for the local element.

Parameters

var_name	Name of coupled array variable
comp	Component number for vector of coupled array variables

Returns

Reference to a VariableValue for the DoFs of the coupled variable

Definition at line 1991 of file Coupleable.C.

{
  const auto * var = getArrayVar(var_name, comp);
  if (!var)
    return *getDefaultArrayValue(var_name);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
  return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
}

coupledArrayDot()

const ArrayVariableValue & Coupleable::coupledArrayDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Time derivative of a coupled array variable.

Parameters

var_name	Name of coupled array variable
comp	Component number for vector of coupled array variables

Returns

Reference to a ArrayVariableValue containing the time derivative of the coupled variable

Definition at line 1318 of file Coupleable.C.

{
  const auto * var = getArrayVar(var_name, comp);
  if (!var)
    return _default_array_value_zero;
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesDot();
    return var->uDot();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesDotNeighbor();
    return var->uDotNeighbor();
  }
}

coupledArrayDotDot()

const ArrayVariableValue & Coupleable::coupledArrayDotDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Second time derivative of a coupled array variable.

Parameters

var_name	Name of coupled array variable
comp	Component number for vector of coupled array variables

Returns

Reference to a ArrayVariableValue containing the time derivative of the coupled variable

Definition at line 1340 of file Coupleable.C.

{
  const auto * var = getArrayVar(var_name, comp);
  if (!var)
    return _default_array_value_zero;
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesDotDot();
    return var->uDotDot();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesDotDotNeighbor();
    return var->uDotDotNeighbor();
  }
}

coupledArrayDotDotOld()

const ArrayVariableValue & Coupleable::coupledArrayDotDotOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Old second time derivative of a coupled array variable.

Parameters

var_name	Name of coupled array variable
comp	Component number for vector of coupled array variables

Returns

Reference to a ArrayVariableValue containing the time derivative of the coupled variable

Definition at line 1384 of file Coupleable.C.

{
  const auto * var = getArrayVar(var_name, comp);
  if (!var)
    return _default_array_value_zero;
  checkFuncType(var_name, VarType::Dot, FuncAge::Old);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesDotDotOld();
    return var->uDotDotOld();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesDotDotOldNeighbor();
    return var->uDotDotOldNeighbor();
  }
}

coupledArrayDotDu()

const VariableValue & Coupleable::coupledArrayDotDu ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Time derivative of a coupled array variable with respect to the coefficients.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a ArrayVariableValue containing the time derivative of the coupled variable

Definition at line 1456 of file Coupleable.C.

{
  const auto * const var = getArrayVar(var_name, comp);
  if (!var)
  {
    _default_value_zero.resize(_coupleable_max_qps, 0);
    return _default_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesDuDotDu();
    return var->duDotDu();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesDuDotDuNeighbor();
    return var->duDotDuNeighbor();
  }
}

coupledArrayDotOld()

const ArrayVariableValue & Coupleable::coupledArrayDotOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Old time derivative of a coupled array variable.

Parameters

var_name	Name of coupled array variable
comp	Component number for vector of coupled array variables

Returns

Reference to a ArrayVariableValue containing the time derivative of the coupled variable

Definition at line 1362 of file Coupleable.C.

{
  const auto * var = getArrayVar(var_name, comp);
  if (!var)
    return _default_array_value_zero;
  checkFuncType(var_name, VarType::Dot, FuncAge::Old);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesDotOld();
    return var->uDotOld();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesDotOldNeighbor();
    return var->uDotOldNeighbor();
  }
}

coupledArrayGradient()

const ArrayVariableGradient & Coupleable::coupledArrayGradient ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns gradient of a coupled array variable.

Parameters

var_name	Name of coupled array variable
comp	Component number for vector of coupled array variables

Returns

Reference to a VectorVariableGradient containing the gradient of the coupled array variable

Definition at line 1626 of file Coupleable.C.

{
  const auto * var = getArrayVar(var_name, comp);
  if (!var)
    return _default_array_gradient;
  checkFuncType(var_name, VarType::Gradient, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->gradSln() : var->gradSlnOld();
  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
}

coupledArrayGradientDot()

const ArrayVariableGradient & Coupleable::coupledArrayGradientDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Retun a gradient of a coupled array variable's time derivative.

Parameters

var_name	Name of coupled array variable
comp	Component number for vector of coupled array variables

Returns

Reference to a ArrayVariableGradient containing the gradient of the time derivative the coupled array variable

Definition at line 1665 of file Coupleable.C.

{
  const auto * const var = getArrayVar(var_name, comp);
  if (!var)
    return _default_array_gradient;
  checkFuncType(var_name, VarType::Gradient, FuncAge::Older);

  if (!_coupleable_neighbor)
    return var->gradSlnDot();
  return var->gradSlnNeighborDot();
}

coupledArrayGradientOld()

const ArrayVariableGradient & Coupleable::coupledArrayGradientOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old gradient from previous time step of a coupled array variable.

Parameters

var_name	Name of coupled array variable
comp	Component number for vector of coupled array variables

Returns

Reference to a VectorVariableGradient containing the old gradient of the coupled array variable

Definition at line 1639 of file Coupleable.C.

{
  const auto * var = getArrayVar(var_name, comp);
  if (!var)
    return _default_array_gradient;
  checkFuncType(var_name, VarType::Gradient, FuncAge::Old);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
}

coupledArrayGradientOlder()

const ArrayVariableGradient & Coupleable::coupledArrayGradientOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old gradient from two time steps previous of a coupled array variable.

Parameters

var_name	Name of coupled array variable
comp	Component number for vector of coupled array variables

Returns

Reference to a ArrayVariableGradient containing the older gradient of the coupled array variable

Definition at line 1652 of file Coupleable.C.

{
  const auto * var = getArrayVar(var_name, comp);
  if (!var)
    return _default_array_gradient;
  checkFuncType(var_name, VarType::Gradient, FuncAge::Older);

  if (!_coupleable_neighbor)
    return var->gradSlnOlder();
  return var->gradSlnOlderNeighbor();
}

coupledArrayNeighborGradient()

const ArrayVariableGradient & NeighborCoupleable::coupledArrayNeighborGradient ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 287 of file NeighborCoupleable.C.

{
  if (_neighbor_nodal)
    mooseError("Gradients are non-sensical with nodal compute objects");

  const auto * var = getArrayVar(var_name, comp);
  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
}

coupledArrayNeighborGradientOld()

const ArrayVariableGradient & NeighborCoupleable::coupledArrayNeighborGradientOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 298 of file NeighborCoupleable.C.

{
  if (_neighbor_nodal)
    mooseError("Gradients are non-sensical with nodal compute objects");

  validateExecutionerType(var_name, "coupledArrayNeighborGradientOld");
  const auto * var = getArrayVar(var_name, comp);
  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
}

coupledArrayNeighborGradientOlder()

const ArrayVariableGradient & NeighborCoupleable::coupledArrayNeighborGradientOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 310 of file NeighborCoupleable.C.

{
  if (_neighbor_nodal)
    mooseError("Gradients are non-sensical with nodal compute objects");

  validateExecutionerType(var_name, "coupledArrayNeighborGradientOlder");
  const auto * var = getArrayVar(var_name, comp);
  if (_c_is_implicit)
    return var->gradSlnOlderNeighbor();
  else
    mooseError("Older values not available for explicit schemes");
}

coupledArrayNeighborValue()

const ArrayVariableValue & NeighborCoupleable::coupledArrayNeighborValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 277 of file NeighborCoupleable.C.

{
  const auto * var = getArrayVar(var_name, comp);
  if (_neighbor_nodal)
    return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
  else
    return (_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
}

coupledArrayValue()

const ArrayVariableValue & Coupleable::coupledArrayValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns value of a coupled array variable.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a ArrayVariableValue for the coupled vector variable

See also

ArrayKernel::_u

Definition at line 834 of file Coupleable.C.

Referenced by Coupleable::coupledArrayValues().

{
  const auto * var = getArrayVar(var_name, comp);
  if (!var)
    return *getDefaultArrayValue(var_name);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return (_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
    return (_c_is_implicit) ? var->sln() : var->slnOld();
  }
  else
  {
    if (_c_nodal)
      return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
    return (_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
  }
}

coupledArrayValueOld()

const ArrayVariableValue & Coupleable::coupledArrayValueOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old value from previous time step of a coupled array variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a ArrayVariableValue containing the old value of the coupled variable

See also

ArrayKernel::_u_old

Definition at line 1078 of file Coupleable.C.

{
  const auto * var = getArrayVar(var_name, comp);
  if (!var)
    return *getDefaultArrayValue(var_name);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Old);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return (_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
    return (_c_is_implicit) ? var->slnOld() : var->slnOlder();
  }
  else
  {
    if (_c_nodal)
      return (_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
    return (_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
  }
}

coupledArrayValueOlder()

const ArrayVariableValue & Coupleable::coupledArrayValueOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old value from two time steps previous of a coupled array variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a ArrayVariableValue containing the older value of the coupled variable

See also

ArrayKernel::_u_older

Definition at line 1100 of file Coupleable.C.

{
  const auto * var = getArrayVar(var_name, comp);
  if (!var)
    return *getDefaultArrayValue(var_name);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Older);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesOlder();
    return var->slnOlder();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesOlderNeighbor();
    return var->slnOlderNeighbor();
  }
}

coupledArrayValues()

std::vector< const ArrayVariableValue * > Coupleable::coupledArrayValues ( const std::string &  var_name ) const

protectedinherited

Returns the values for all of a coupled array variable's components.

Parameters

var_name

Name of coupled array variable

Returns

Vector of ArrayVariableValue pointers for each component of var_name

Definition at line 856 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &coupledArrayValue(var_name, comp); };
  return coupledVectorHelper<const ArrayVariableValue *>(var_name, func);
}

coupledCallback()

virtual void Coupleable::coupledCallback ( const std::string &  , bool    ) const

inlineprotectedvirtualinherited

A call-back function provided by the derived object for actions before coupling a variable with functions such as coupledValue.

Reimplemented in AuxKernelTempl< ComputeValueType >, AuxKernelTempl< RT >, AuxKernelTempl< RealVectorValue >, and AuxKernelTempl< Real >.

Definition at line 135 of file Coupleable.h.

Referenced by Coupleable::checkFuncType().

{}

coupledComponents()

unsigned int Coupleable::coupledComponents ( const std::string &  var_name ) const

protectedinherited

Number of coupled components.

Parameters

var_name

Name of the variable

Returns

number of components this variable has (usually 1)

Definition at line 157 of file Coupleable.C.

Referenced by Coupleable::coupledVectorHelper(), KernelBase::KernelBase(), SpatialAverageBase::SpatialAverageBase(), and VariableValueVolumeHistogram::VariableValueVolumeHistogram().

{
  const auto var_name = _c_parameters.checkForRename(var_name_in);

  if (isCoupled(var_name))
  {
    mooseAssert(_coupled_vars.find(var_name) != _coupled_vars.end(),
                var_name << " must not actually be coupled!");
    return _coupled_vars.at(var_name).size();
  }
  else
  {
    if (_c_parameters.hasDefaultCoupledValue(var_name))
      return _c_parameters.numberDefaultCoupledValues(var_name);
    else
      return 0;
  }
}

coupledCurl()

const VectorVariableCurl & Coupleable::coupledCurl ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns curl of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VectorVariableCurl containing the curl of the coupled variable

See also

Kernel::_curl_u

Definition at line 1678 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
  {
    _default_vector_curl.resize(_coupleable_max_qps);
    return _default_vector_curl;
  }
  checkFuncType(var_name, VarType::Gradient, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->curlSln() : var->curlSlnOld();
  return (_c_is_implicit) ? var->curlSlnNeighbor() : var->curlSlnOldNeighbor();
}

coupledCurlOld()

const VectorVariableCurl & Coupleable::coupledCurlOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old curl from previous time step of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VectorVariableCurl containing the old curl of the coupled variable

See also

Kernel::_curl_u_old

Definition at line 1694 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
  {
    _default_vector_curl.resize(_coupleable_max_qps);
    return _default_vector_curl;
  }
  checkFuncType(var_name, VarType::Gradient, FuncAge::Old);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->curlSlnOld() : var->curlSlnOlder();
  return (_c_is_implicit) ? var->curlSlnOldNeighbor() : var->curlSlnOlderNeighbor();
}

coupledCurlOlder()

const VectorVariableCurl & Coupleable::coupledCurlOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old curl from two time steps previous of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VectorVariableCurl containing the older curl of the coupled variable

See also

Kernel::_curl_u_older

Definition at line 1710 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
  {
    _default_vector_curl.resize(_coupleable_max_qps);
    return _default_vector_curl;
  }
  checkFuncType(var_name, VarType::Gradient, FuncAge::Older);

  if (!_coupleable_neighbor)
    return var->curlSlnOlder();
  return var->curlSlnOlderNeighbor();
}

coupledDofValues()

const VariableValue & Coupleable::coupledDofValues ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns DoFs in the current solution vector of a coupled variable for the local element.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the DoFs of the coupled variable

Definition at line 1930 of file Coupleable.C.

Referenced by Coupleable::coupledAllDofValues().

{
  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
  if (!var)
    return *getDefaultValue(var_name, comp);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
  return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
}

coupledDofValuesOld()

const VariableValue & Coupleable::coupledDofValuesOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns DoFs in the old solution vector of a coupled variable for the local element.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the old DoFs of the coupled variable

Definition at line 1950 of file Coupleable.C.

Referenced by Coupleable::coupledAllDofValuesOld().

{
  const auto * var = getVar(var_name, comp);
  if (!var)
    return *getDefaultValue(var_name, comp);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Old);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
  return (_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
}

coupledDofValuesOlder()

const VariableValue & Coupleable::coupledDofValuesOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns DoFs in the older solution vector of a coupled variable for the local element.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the older DoFs of the coupled variable

Definition at line 1970 of file Coupleable.C.

Referenced by Coupleable::coupledAllDofValuesOlder().

{
  const auto * var = getVar(var_name, comp);
  if (!var)
    return *getDefaultValue(var_name, comp);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Older);

  if (!_coupleable_neighbor)
    return var->dofValuesOlder();
  return var->dofValuesOlderNeighbor();
}

coupledDot()

const VariableValue & Coupleable::coupledDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Time derivative of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the time derivative of the coupled variable

Reimplemented in AuxKernelTempl< ComputeValueType >, AuxKernelTempl< RT >, AuxKernelTempl< RealVectorValue >, and AuxKernelTempl< Real >.

Definition at line 1122 of file Coupleable.C.

Referenced by AuxKernelTempl< Real >::coupledDot(), and Coupleable::coupledDots().

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_value_zero.resize(_coupleable_max_qps, 0);
    return _default_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesDot();
    return var->uDot();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesDotNeighbor();
    return var->uDotNeighbor();
  }
}

coupledDotDot()

const VariableValue & Coupleable::coupledDotDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Second time derivative of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the second time derivative of the coupled variable

Definition at line 1147 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_value_zero.resize(_coupleable_max_qps, 0);
    return _default_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesDotDot();
    return var->uDotDot();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesDotDotNeighbor();
    return var->uDotDotNeighbor();
  }
}

coupledDotDotDu()

const VariableValue & Coupleable::coupledDotDotDu ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Second time derivative of a coupled variable with respect to the coefficients.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the time derivative of the coupled variable with respect to the coefficients

Definition at line 1431 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_value_zero.resize(_coupleable_max_qps, 0);
    return _default_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesDuDotDotDu();
    return var->duDotDotDu();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesDuDotDotDuNeighbor();
    return var->duDotDotDuNeighbor();
  }
}

coupledDotDotOld()

const VariableValue & Coupleable::coupledDotDotOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Old second time derivative of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the old second time derivative of the coupled variable

Definition at line 1197 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_value_zero.resize(_coupleable_max_qps, 0);
    return _default_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Old);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesDotDotOld();
    return var->uDotDotOld();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesDotDotOldNeighbor();
    return var->uDotDotOldNeighbor();
  }
}

coupledDotDu()

const VariableValue & Coupleable::coupledDotDu ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Time derivative of a coupled variable with respect to the coefficients.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the time derivative of the coupled variable with respect to the coefficients

Reimplemented in AuxKernelTempl< ComputeValueType >, AuxKernelTempl< RT >, AuxKernelTempl< RealVectorValue >, and AuxKernelTempl< Real >.

Definition at line 1406 of file Coupleable.C.

Referenced by AuxKernelTempl< Real >::coupledDotDu().

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_value_zero.resize(_coupleable_max_qps, 0);
    return _default_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesDuDotDu();
    return var->duDotDu();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesDuDotDuNeighbor();
    return var->duDotDuNeighbor();
  }
}

coupledDotOld()

const VariableValue & Coupleable::coupledDotOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Old time derivative of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the old time derivative of the coupled variable

Definition at line 1172 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_value_zero.resize(_coupleable_max_qps, 0);
    return _default_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Old);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesDotOld();
    return var->uDotOld();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesDotOldNeighbor();
    return var->uDotOldNeighbor();
  }
}

coupledDots()

std::vector< const VariableValue * > Coupleable::coupledDots ( const std::string &  var_name ) const

protectedinherited

Returns the time derivatives for all of a coupled variable's components.

Parameters

var_name

Name of coupled variable

Returns

Vector of VariableValue pointers for each component of var_name

Definition at line 2629 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &coupledDot(var_name, comp); };
  return coupledVectorHelper<const VariableValue *>(var_name, func);
}

coupledGenericDofValue() [1/3]

template<bool is_ad>

const GenericVariableValue<is_ad>& Coupleable::coupledGenericDofValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns DOF value of a coupled variable for use in templated automatic differentiation classes.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a GenericVariableValue for the coupled variable

coupledGenericDofValue() [2/3]

template<>

const GenericVariableValue<false>& Coupleable::coupledGenericDofValue ( const std::string &  var_name, unsigned int  comp  ) const

protectedinherited

Definition at line 574 of file Coupleable.C.

{
  return coupledDofValues(var_name, comp);
}

coupledGenericDofValue() [3/3]

template<>

const GenericVariableValue<true>& Coupleable::coupledGenericDofValue ( const std::string &  var_name, unsigned int  comp  ) const

protectedinherited

Definition at line 581 of file Coupleable.C.

{
  return adCoupledDofValues(var_name, comp);
}

coupledGenericGradient() [1/3]

template<bool is_ad>

const GenericVariableGradient<is_ad>& Coupleable::coupledGenericGradient ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns gradient of a coupled variable for use in templated automatic differentiation.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableGradient containing the gradient of the coupled variable

See also

Kernel::gradient

coupledGenericGradient() [2/3]

template<>

const GenericVariableGradient<false>& Coupleable::coupledGenericGradient ( const std::string &  var_name, unsigned int  comp  ) const

protectedinherited

Definition at line 2354 of file Coupleable.C.

{
  return coupledGradient(var_name, comp);
}

coupledGenericGradient() [3/3]

template<>

const GenericVariableGradient<true>& Coupleable::coupledGenericGradient ( const std::string &  var_name, unsigned int  comp  ) const

protectedinherited

Definition at line 2361 of file Coupleable.C.

{
  return adCoupledGradient(var_name, comp);
}

coupledGenericGradients() [1/3]

template<bool is_ad>

std::vector<const GenericVariableGradient<is_ad> *> Coupleable::coupledGenericGradients ( const std::string &  var_name ) const

protectedinherited

Returns the gradients for all of a coupled variable's components for use in templated automatic differentiation.

Parameters

var_name

Name of coupled variable

Returns

Vector of VariableGradient pointers for each component of var_name

coupledGenericGradients() [2/3]

template<>

std::vector<const GenericVariableGradient<true> *> Coupleable::coupledGenericGradients ( const std::string &  var_name ) const

protectedinherited

Definition at line 2608 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &adCoupledGradient(var_name, comp); };
  return coupledVectorHelper<const GenericVariableGradient<true> *>(var_name, func);
}

coupledGenericGradients() [3/3]

template<>

std::vector<const GenericVariableGradient<false> *> Coupleable::coupledGenericGradients ( const std::string &  var_name ) const

protectedinherited

Definition at line 2601 of file Coupleable.C.

{
  return coupledGradients(var_name);
}

coupledGenericNeighborGradient()

template<bool is_ad>

const auto & NeighborCoupleable::coupledGenericNeighborGradient ( const std::string &  var_name, unsigned int  comp = 0  ) const

inherited

Retrieve the coupled neighbor variable gradient whether AD or not.

Definition at line 147 of file NeighborCoupleable.h.

{
  if constexpr (is_ad)
    return adCoupledNeighborGradient(var_name, comp);
  else
    return coupledNeighborGradient(var_name, comp);
}

coupledGenericNeighborValue()

template<bool is_ad>

const auto & NeighborCoupleable::coupledGenericNeighborValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

inherited

Retrieve the coupled neighbor variable value whether AD or not.

Definition at line 136 of file NeighborCoupleable.h.

{
  if constexpr (is_ad)
    return adCoupledNeighborValue(var_name, comp);
  else
    return coupledNeighborValue(var_name, comp);
}

coupledGenericScalarValue() [1/3]

template<bool is_ad>

const GenericVariableValue<is_ad>& ScalarCoupleable::coupledGenericScalarValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns value of a coupled scalar variable for use in templated automatic differentiation classes.

Parameters

var_name	Name of coupled scalar variable
comp	Component number for vector of coupled scalar variables

Returns

Reference to a GenericVariableValue for the coupled scalar variable

coupledGenericScalarValue() [2/3]

template<>

const GenericVariableValue<false>& ScalarCoupleable::coupledGenericScalarValue ( const std::string &  var_name, const unsigned int  comp  ) const

protectedinherited

Definition at line 152 of file ScalarCoupleable.C.

{
  return coupledScalarValue(var_name, comp);
}

coupledGenericScalarValue() [3/3]

template<>

const GenericVariableValue<true>& ScalarCoupleable::coupledGenericScalarValue ( const std::string &  var_name, const unsigned int  comp  ) const

protectedinherited

Definition at line 160 of file ScalarCoupleable.C.

{
  return adCoupledScalarValue(var_name, comp);
}

coupledGenericValue() [1/3]

template<bool is_ad>

const GenericVariableValue<is_ad>& Coupleable::coupledGenericValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns value of a coupled variable for use in templated automatic differentiation classes.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a GenericVariableValue for the coupled variable

coupledGenericValue() [2/3]

template<>

const GenericVariableValue<false>& Coupleable::coupledGenericValue ( const std::string &  var_name, unsigned int  comp  ) const

protectedinherited

Definition at line 469 of file Coupleable.C.

{
  return coupledValue(var_name, comp);
}

coupledGenericValue() [3/3]

template<>

const GenericVariableValue<true>& Coupleable::coupledGenericValue ( const std::string &  var_name, unsigned int  comp  ) const

protectedinherited

Definition at line 476 of file Coupleable.C.

{
  return adCoupledValue(var_name, comp);
}

coupledGenericValues() [1/3]

template<bool is_ad>

std::vector<const GenericVariableValue<is_ad> *> Coupleable::coupledGenericValues ( const std::string &  var_name ) const

protectedinherited

Returns the values for all of a coupled variable's components for use in templated automatic differentiation classes.

Parameters

var_name

Name of coupled variable

Returns

Vector of GenericVariableValue pointers for each component of var_name

coupledGenericValues() [2/3]

template<>

std::vector<const GenericVariableValue<true> *> Coupleable::coupledGenericValues ( const std::string &  var_name ) const

protectedinherited

Definition at line 2420 of file Coupleable.C.

{
  return adCoupledValues(var_name);
}

coupledGenericValues() [3/3]

template<>

std::vector<const GenericVariableValue<false> *> Coupleable::coupledGenericValues ( const std::string &  var_name ) const

protectedinherited

Definition at line 2413 of file Coupleable.C.

{
  return coupledValues(var_name);
}

coupledGradient()

const VariableGradient & Coupleable::coupledGradient ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns gradient of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableGradient containing the gradient of the coupled variable

See also

Kernel::gradient

Definition at line 1481 of file Coupleable.C.

Referenced by Coupleable::coupledGradients(), NodeElemConstraint::coupledSecondaryGradient(), and NodeFaceConstraint::coupledSecondaryGradient().

{
  const auto * const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
  if (!var)
  {
    _default_gradient.resize(_coupleable_max_qps);
    return _default_gradient;
  }
  checkFuncType(var_name, VarType::Gradient, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->gradSln() : var->gradSlnOld();
  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
}

coupledGradientDot()

const VariableGradient & Coupleable::coupledGradientDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Time derivative of the gradient of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableGradient containing the time derivative of the gradient of a coupled variable

Definition at line 1546 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_gradient.resize(_coupleable_max_qps);
    return _default_gradient;
  }
  checkFuncType(var_name, VarType::GradientDot, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return var->gradSlnDot();
  return var->gradSlnNeighborDot();
}

coupledGradientDotDot()

const VariableGradient & Coupleable::coupledGradientDotDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Second time derivative of the gradient of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableGradient containing the time derivative of the gradient of a coupled variable

Definition at line 1562 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_gradient.resize(_coupleable_max_qps);
    return _default_gradient;
  }
  checkFuncType(var_name, VarType::GradientDot, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return var->gradSlnDotDot();
  return var->gradSlnNeighborDotDot();
}

coupledGradientOld()

const VariableGradient & Coupleable::coupledGradientOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old gradient from previous time step of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableGradient containing the old gradient of the coupled variable

See also

Kernel::gradientOld

Definition at line 1497 of file Coupleable.C.

Referenced by Coupleable::coupledGradientsOld(), NodeElemConstraint::coupledSecondaryGradientOld(), and NodeFaceConstraint::coupledSecondaryGradientOld().

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_gradient.resize(_coupleable_max_qps);
    return _default_gradient;
  }
  checkFuncType(var_name, VarType::Gradient, FuncAge::Old);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
}

coupledGradientOlder()

const VariableGradient & Coupleable::coupledGradientOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old gradient from two time steps previous of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableGradient containing the older gradient of the coupled variable

See also

Kernel::gradientOlder

Definition at line 1513 of file Coupleable.C.

Referenced by NodeElemConstraint::coupledSecondaryGradientOlder(), and NodeFaceConstraint::coupledSecondaryGradientOlder().

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_gradient.resize(_coupleable_max_qps);
    return _default_gradient;
  }
  checkFuncType(var_name, VarType::Gradient, FuncAge::Older);

  if (!_coupleable_neighbor)
    return var->gradSlnOlder();
  return var->gradSlnOlderNeighbor();
}

coupledGradientPreviousNL()

const VariableGradient & Coupleable::coupledGradientPreviousNL ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns gradient of a coupled variable for previous Newton iterate.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableGradient containing the gradient of the coupled variable

Definition at line 1529 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  _c_fe_problem.needsPreviousNewtonIteration(true);
  if (!var)
  {
    _default_gradient.resize(_coupleable_max_qps);
    return _default_gradient;
  }
  checkFuncType(var_name, VarType::Gradient, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return var->gradSlnPreviousNL();
  return var->gradSlnPreviousNLNeighbor();
}

coupledGradients()

std::vector< const VariableGradient * > Coupleable::coupledGradients ( const std::string &  var_name ) const

protectedinherited

Returns the gradients for all of a coupled variable's components.

Parameters

var_name

Name of coupled variable

Returns

Vector of VariableGradient pointers for each component of var_name

Definition at line 2593 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &coupledGradient(var_name, comp); };
  return coupledVectorHelper<const VariableGradient *>(var_name, func);
}

coupledGradientsOld()

std::vector< const VariableGradient * > Coupleable::coupledGradientsOld ( const std::string &  var_name ) const

protectedinherited

Returns the old gradients for all of a coupled variable's components.

Parameters

var_name

Name of coupled variable

Returns

Vector of VariableGradient pointers for each component of var_name

Definition at line 2622 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &coupledGradientOld(var_name, comp); };
  return coupledVectorHelper<const VariableGradient *>(var_name, func);
}

coupledIndices()

std::vector< unsigned int > Coupleable::coupledIndices ( const std::string &  var_name ) const

protectedinherited

Returns the indices for a coupled variable's components.

Parameters

var_name

Name of coupled variable

Returns

Vector of the indices for all components of the coupled variable var_name.

Definition at line 2367 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return coupled(var_name, comp); };
  return coupledVectorHelper<unsigned int>(var_name, func);
}

coupledMatrixTagScalarValue()

const VariableValue & ScalarCoupleable::coupledMatrixTagScalarValue ( const std::string &  var_name, TagID  tag, unsigned int  comp = 0  ) const

protectedinherited

Returns value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
tag	Tag ID of coupled matrix;
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

Definition at line 202 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return *getDefaultValue(var_name);

  _sc_coupleable_matrix_tags.insert(tag);

  return getScalarVar(var_name, comp)->matrixTagSln(tag);
}

coupledMatrixTagValue() [1/2]

const VariableValue & Coupleable::coupledMatrixTagValue ( const std::string &  var_names, TagID  tag, unsigned int  index = 0  ) const

protectedvirtualinherited

Returns value of a coupled variable for a given tag.

This couples the diag vector of matrix

Parameters

var_names	Name(s) of coupled variable(s)
tag	matrix tag ID
index	Index of the desired variable in the vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

See also

Kernel::_u

Definition at line 776 of file Coupleable.C.

Referenced by Coupleable::coupledMatrixTagValue(), and Coupleable::coupledMatrixTagValues().

{
  const auto * var = getVarHelper<MooseVariableField<Real>>(var_names, index);
  if (!var)
    mooseError(var_names, ": invalid variable name for coupledMatrixTagValue");
  checkFuncType(var_names, VarType::Ignore, FuncAge::Curr);

  const_cast<Coupleable *>(this)->addFEVariableCoupleableMatrixTag(tag);

  if (_c_nodal)
    return var->nodalMatrixTagValue(tag);
  return var->matrixTagValue(tag);
}

coupledMatrixTagValue() [2/2]

const VariableValue & Coupleable::coupledMatrixTagValue ( const std::string &  var_names, const std::string &  tag_name, unsigned int  index = 0  ) const

protectedvirtualinherited

Definition at line 793 of file Coupleable.C.

{
  if (!_c_parameters.isParamValid(tag_name))
    mooseError("Tag name parameter '", tag_name, "' is invalid");

  TagName tagname = _c_parameters.get<TagName>(tag_name);
  if (!_c_fe_problem.matrixTagExists(tagname))
    mooseError("Matrix tag name '", tagname, "' does not exist");

  TagID tag = _c_fe_problem.getMatrixTagID(tagname);
  return coupledMatrixTagValue(var_names, tag, index);
}

coupledMatrixTagValues() [1/2]

std::vector< const VariableValue * > Coupleable::coupledMatrixTagValues ( const std::string &  var_names, TagID  tag  ) const

protectedinherited

Returns the diagonal matrix values for all the coupled variables desired for a given tag.

Parameters

var_names	Name(s) of coupled variable(s)
tag	matrix tag ID

Returns

Vector of VariableValue pointers for each variable in var_name

Definition at line 2556 of file Coupleable.C.

Referenced by Coupleable::coupledMatrixTagValues().

{
  auto func = [this, &var_names, &tag](unsigned int comp)
  { return &coupledMatrixTagValue(var_names, tag, comp); };
  return coupledVectorHelper<const VariableValue *>(var_names, func);
}

coupledMatrixTagValues() [2/2]

std::vector< const VariableValue * > Coupleable::coupledMatrixTagValues ( const std::string &  var_names, const std::string &  tag_name  ) const

protectedinherited

Definition at line 2564 of file Coupleable.C.

{
  if (!_c_parameters.isParamValid(tag_name))
    mooseError("Tag name parameter '", tag_name, "' is invalid");

  TagName tagname = _c_parameters.get<TagName>(tag_name);
  if (!_c_fe_problem.matrixTagExists(tagname))
    mooseError("Matrix tag name '", tagname, "' does not exist");

  TagID tag = _c_fe_problem.getMatrixTagID(tagname);
  return coupledMatrixTagValues(var_names, tag);
}

coupledName()

VariableName Coupleable::coupledName ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Names of the variable in the Coupleable interface.

Parameters

var_name	Name of the variable
comp	the component of the variable

Returns

name the variable has been coupled as. For constants, returns the constant

Definition at line 2374 of file Coupleable.C.

Referenced by Coupleable::coupledNames(), SecondTimeDerivativeAux::SecondTimeDerivativeAux(), and SpatialAverageBase::SpatialAverageBase().

{
  if (getFieldVar(var_name, comp))
    return getFieldVar(var_name, comp)->name();
  // Detect if we are in the case where a constant was passed in lieu of a variable
  else if (isCoupledConstant(var_name))
    mooseError(_c_name,
               ": a variable name was queried but a constant was passed for parameter '",
               var_name,
               "Either pass a true variable or contact a developer to shield the call to "
               "'coupledName' with 'isCoupledConstant'");
  else
    mooseError(
        _c_name, ": Variable '", var_name, "' does not exist, yet its coupled name is requested");
}

coupledNames()

std::vector< VariableName > Coupleable::coupledNames ( const std::string &  var_name ) const

protectedinherited

Names of the variables in the Coupleable interface.

Parameters

var_name

Names of the variables

Returns

names the variables have been coupled as

Definition at line 2391 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return coupledName(var_name, comp); };
  return coupledVectorHelper<VariableName>(var_name, func);
}

coupledNeighborDofValues()

const VariableValue & NeighborCoupleable::coupledNeighborDofValues ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 335 of file NeighborCoupleable.C.

{
  if (_neighbor_nodal)
    mooseError("nodal objects should not call coupledDofValues");

  const auto * var = getVar(var_name, comp);
  return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
}

coupledNeighborDofValuesOld()

const VariableValue & NeighborCoupleable::coupledNeighborDofValuesOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 345 of file NeighborCoupleable.C.

{
  if (_neighbor_nodal)
    mooseError("nodal objects should not call coupledDofValuesOld");

  validateExecutionerType(var_name, "coupledNeighborDofValuesOld");
  const auto * var = getVar(var_name, comp);
  return (_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
}

coupledNeighborDofValuesOlder()

const VariableValue & NeighborCoupleable::coupledNeighborDofValuesOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 357 of file NeighborCoupleable.C.

{
  if (_neighbor_nodal)
    mooseError("nodal objects should not call coupledDofValuesOlder");

  validateExecutionerType(var_name, "coupledNeighborDofValuesOlder");
  const auto * var = getVar(var_name, comp);
  if (_c_is_implicit)
    return var->dofValuesOlderNeighbor();
  else
    mooseError("Older values not available for explicit schemes");
}

coupledNeighborGradient()

const VariableGradient & NeighborCoupleable::coupledNeighborGradient ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 179 of file NeighborCoupleable.C.

Referenced by NeighborCoupleable::coupledGenericNeighborGradient(), NeighborCoupleable::coupledNeighborGradients(), NodeElemConstraint::coupledPrimaryGradient(), and NodeFaceConstraint::coupledPrimaryGradient().

{
  if (_neighbor_nodal)
    mooseError("Nodal variables do not have gradients");

  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
}

coupledNeighborGradientOld()

const VariableGradient & NeighborCoupleable::coupledNeighborGradientOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 197 of file NeighborCoupleable.C.

Referenced by NodeElemConstraint::coupledPrimaryGradientOld(), and NodeFaceConstraint::coupledPrimaryGradientOld().

{
  if (_neighbor_nodal)
    mooseError("Nodal variables do not have gradients");

  validateExecutionerType(var_name, "coupledNeighborGradientOld");
  const auto * var = getVar(var_name, comp);
  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
}

coupledNeighborGradientOlder()

const VariableGradient & NeighborCoupleable::coupledNeighborGradientOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 209 of file NeighborCoupleable.C.

Referenced by NodeElemConstraint::coupledPrimaryGradientOlder(), and NodeFaceConstraint::coupledPrimaryGradientOlder().

{
  if (_neighbor_nodal)
    mooseError("Nodal variables do not have gradients");

  validateExecutionerType(var_name, "coupledNeighborGradientOlder");
  const auto * var = getVar(var_name, comp);
  if (_c_is_implicit)
    return var->gradSlnOlderNeighbor();
  else
    mooseError("Older values not available for explicit schemes");
}

coupledNeighborGradients()

std::vector< const VariableGradient * > NeighborCoupleable::coupledNeighborGradients ( const std::string &  var_name ) const

virtualinherited

Definition at line 189 of file NeighborCoupleable.C.

{
  auto func = [this, &var_name](unsigned int comp)
  { return &coupledNeighborGradient(var_name, comp); };
  return coupledVectorHelper<const VariableGradient *>(var_name, func);
}

coupledNeighborSecond()

const VariableSecond & NeighborCoupleable::coupledNeighborSecond ( const std::string &  var_name, unsigned int  i = 0  ) const

virtualinherited

Definition at line 325 of file NeighborCoupleable.C.

Referenced by NodeElemConstraint::coupledPrimarySecond(), and NodeFaceConstraint::coupledPrimarySecond().

{
  if (_neighbor_nodal)
    mooseError("Nodal variables do not have second derivatives");

  const auto * var = getVar(var_name, comp);
  return (_c_is_implicit) ? var->secondSlnNeighbor() : var->secondSlnOldNeighbor();
}

coupledNeighborValue()

const VariableValue & NeighborCoupleable::coupledNeighborValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 27 of file NeighborCoupleable.C.

Referenced by NeighborCoupleable::coupledGenericNeighborValue(), NeighborCoupleable::coupledNeighborValues(), NodeElemConstraint::coupledPrimaryValue(), and NodeFaceConstraint::coupledPrimaryValue().

{
  const auto * var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
  if (_neighbor_nodal)
    return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
  else
    return (_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
}

coupledNeighborValueDot()

const VariableValue & NeighborCoupleable::coupledNeighborValueDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 125 of file NeighborCoupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (_neighbor_nodal)
    return var->dofValuesDotNeighbor();
  else
    return var->uDotNeighbor();
}

coupledNeighborValueDotDu()

const VariableValue & NeighborCoupleable::coupledNeighborValueDotDu ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 135 of file NeighborCoupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (_neighbor_nodal)
    return var->dofValuesDuDotDuNeighbor();
  else
    return var->duDotDuNeighbor();
}

coupledNeighborValueOld()

const VariableValue & NeighborCoupleable::coupledNeighborValueOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 145 of file NeighborCoupleable.C.

Referenced by NeighborCoupleable::coupledNeighborValuesOld(), NodeElemConstraint::coupledPrimaryValueOld(), and NodeFaceConstraint::coupledPrimaryValueOld().

{
  validateExecutionerType(var_name, "coupledNeighborValueOld");

  const auto * var = getVar(var_name, comp);
  if (_neighbor_nodal)
    return (_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
  else
    return (_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
}

coupledNeighborValueOlder()

const VariableValue & NeighborCoupleable::coupledNeighborValueOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 157 of file NeighborCoupleable.C.

Referenced by NeighborCoupleable::coupledNeighborValuesOlder(), NodeElemConstraint::coupledPrimaryValueOlder(), and NodeFaceConstraint::coupledPrimaryValueOlder().

{
  validateExecutionerType(var_name, "coupledNeighborValueOlder");

  const auto * var = getVar(var_name, comp);
  if (_neighbor_nodal)
  {
    if (_c_is_implicit)
      return var->dofValuesOlderNeighbor();
    else
      mooseError("Older values not available for explicit schemes");
  }
  else
  {
    if (_c_is_implicit)
      return var->slnOlderNeighbor();
    else
      mooseError("Older values not available for explicit schemes");
  }
}

coupledNeighborValues()

std::vector< const VariableValue * > NeighborCoupleable::coupledNeighborValues ( const std::string &  var_name ) const

inherited

Definition at line 37 of file NeighborCoupleable.C.

{
  auto func = [this, &var_name](unsigned int comp)
  { return &coupledNeighborValue(var_name, comp); };
  return coupledVectorHelper<const VariableValue *>(var_name, func);
}

coupledNeighborValuesOld()

std::vector< const VariableValue * > NeighborCoupleable::coupledNeighborValuesOld ( const std::string &  var_name ) const

inherited

Definition at line 45 of file NeighborCoupleable.C.

{
  auto func = [this, &var_name](unsigned int comp)
  { return &coupledNeighborValueOld(var_name, comp); };
  return coupledVectorHelper<const VariableValue *>(var_name, func);
}

coupledNeighborValuesOlder()

std::vector< const VariableValue * > NeighborCoupleable::coupledNeighborValuesOlder ( const std::string &  var_name ) const

inherited

Definition at line 53 of file NeighborCoupleable.C.

{
  auto func = [this, &var_name](unsigned int comp)
  { return &coupledNeighborValueOlder(var_name, comp); };
  return coupledVectorHelper<const VariableValue *>(var_name, func);
}

coupledNodalDot()

template<typename T >

template const RealVectorValue & Coupleable::coupledNodalDot< RealVectorValue > ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Nodal values of time derivative of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the nodal values of time derivative of the coupled variable

Definition at line 1868 of file Coupleable.C.

{
  static const T zero = 0;
  const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
  if (!var)
    return zero;
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return var->nodalValueDot();
  mooseError("Neighbor version not implemented");
}

coupledNodalDotDot()

const VariableValue & Coupleable::coupledNodalDotDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Nodal values of second time derivative of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the nodal values of second time derivative of the coupled variable

Definition at line 1882 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_value_zero.resize(_coupleable_max_qps, 0);
    return _default_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return var->dofValuesDotDot();
  return var->dofValuesDotDotNeighbor();
}

coupledNodalDotDotOld()

const VariableValue & Coupleable::coupledNodalDotDotOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Nodal values of old second time derivative of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the nodal values of second time derivative of the coupled variable

Definition at line 1914 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_value_zero.resize(_coupleable_max_qps, 0);
    return _default_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Old);

  if (!_coupleable_neighbor)
    return var->dofValuesDotDotOld();
  return var->dofValuesDotDotOldNeighbor();
}

coupledNodalDotOld()

const VariableValue & Coupleable::coupledNodalDotOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Nodal values of old time derivative of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the nodal values of time derivative of the coupled variable

Definition at line 1898 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_value_zero.resize(_coupleable_max_qps, 0);
    return _default_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Old);

  if (!_coupleable_neighbor)
    return var->dofValuesDotOld();
  return var->dofValuesDotOldNeighbor();
}

coupledNodalValue()

template<typename T >

template const RealVectorValue & Coupleable::coupledNodalValue< RealVectorValue > ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns nodal values of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

Definition at line 1792 of file Coupleable.C.

{
  const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
  if (!var)
    return getDefaultNodalValue<T>(var_name, comp);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  if (!var->isNodal())
    mooseError(_c_name,
               ": Trying to get nodal values of variable '",
               var->name(),
               "', but it is not nodal.");

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->nodalValue() : var->nodalValueOld();
  return (_c_is_implicit) ? var->nodalValueNeighbor() : var->nodalValueOldNeighbor();
}

coupledNodalValueOld()

template<typename T >

template const RealVectorValue & Coupleable::coupledNodalValueOld< RealVectorValue > ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns an old nodal value from previous time step of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the old value of the coupled variable

Definition at line 1812 of file Coupleable.C.

{
  const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
  if (!var)
    return getDefaultNodalValue<T>(var_name, comp);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Old);

  if (!var->isNodal())
    mooseError(_c_name,
               ": Trying to get old nodal values of variable '",
               var->name(),
               "', but it is not nodal.");

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->nodalValueOld() : var->nodalValueOlder();
  return (_c_is_implicit) ? var->nodalValueOldNeighbor() : var->nodalValueOlderNeighbor();
}

coupledNodalValueOlder()

template<typename T >

template const RealVectorValue & Coupleable::coupledNodalValueOlder< RealVectorValue > ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns an old nodal value from two time steps previous of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the older value of the coupled variable

Definition at line 1832 of file Coupleable.C.

{
  const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
  if (!var)
    return getDefaultNodalValue<T>(var_name, comp);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Older);

  if (!var->isNodal())
    mooseError(_c_name,
               ": Trying to get older nodal values of variable '",
               var->name(),
               "', but it is not nodal.");

  if (!_coupleable_neighbor)
    return var->nodalValueOlder();
  return var->nodalValueOlderNeighbor();
}

coupledNodalValuePreviousNL()

template<typename T >

template const RealVectorValue & Coupleable::coupledNodalValuePreviousNL< RealVectorValue > ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns nodal values of a coupled variable for previous Newton iterate.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

Definition at line 1852 of file Coupleable.C.

{
  const auto * var = getVarHelper<MooseVariableFE<T>>(var_name, comp);
  if (!var)
    return getDefaultNodalValue<T>(var_name, comp);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  _c_fe_problem.needsPreviousNewtonIteration(true);

  if (!_coupleable_neighbor)
    return var->nodalValuePreviousNL();
  return var->nodalValuePreviousNLNeighbor();
}

coupledScalar()

unsigned int ScalarCoupleable::coupledScalar ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns the index for a scalar coupled variable by name.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Index of coupled variable

Definition at line 93 of file ScalarCoupleable.C.

Referenced by ParsedODEKernel::ParsedODEKernel().

{
  checkVar(var_name);
  return getScalarVar(var_name, comp)->number();
}

coupledScalarComponents()

unsigned int ScalarCoupleable::coupledScalarComponents ( const std::string &  var_name ) const

protectedinherited

Return the number of components to the coupled scalar variable.

Parameters

var_name

The of the coupled variable

Definition at line 353 of file ScalarCoupleable.C.

{
  const auto var_name = _sc_parameters.checkForRename(var_name_in);

  const auto it = _coupled_scalar_vars.find(var_name);
  if (it != _coupled_scalar_vars.end())
    return it->second.size();

  mooseError(_sc_name, ": Trying to get a non-existent variable '", var_name, "'");
}

coupledScalarDot()

const VariableValue & ScalarCoupleable::coupledScalarDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns the time derivative of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a time derivative VariableValue for the coupled variable

Definition at line 244 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "coupledScalarDot");
  return getScalarVar(var_name, comp)->uDot();
}

coupledScalarDotDot()

const VariableValue & ScalarCoupleable::coupledScalarDotDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns the second time derivative of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a time derivative VariableValue for the coupled variable

Definition at line 260 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "coupledScalarDotDot");
  return getScalarVar(var_name, comp)->uDotDot();
}

coupledScalarDotDotDu()

const VariableValue & ScalarCoupleable::coupledScalarDotDotDu ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Second time derivative of a scalar coupled variable with respect to the coefficients.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the time derivative of the coupled variable with respect to the coefficients

Definition at line 292 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "coupledScalarDotDotDu");
  return getScalarVar(var_name, comp)->duDotDotDu();
}

coupledScalarDotDotOld()

const VariableValue & ScalarCoupleable::coupledScalarDotDotOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns the old second time derivative of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a time derivative VariableValue for the coupled variable

Definition at line 276 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "coupledScalarDotDotOld");
  return getScalarVar(var_name, comp)->uDotDotOld();
}

coupledScalarDotDu()

const VariableValue & ScalarCoupleable::coupledScalarDotDu ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Time derivative of a scalar coupled variable with respect to the coefficients.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the time derivative of the coupled variable with respect to the coefficients

Definition at line 284 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "coupledScalarDotDu");
  return getScalarVar(var_name, comp)->duDotDu();
}

coupledScalarDotOld()

const VariableValue & ScalarCoupleable::coupledScalarDotOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns the old time derivative of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a time derivative VariableValue for the coupled variable

Definition at line 268 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  validateExecutionerType(var_name, "coupledScalarDotOld");
  return getScalarVar(var_name, comp)->uDotOld();
}

coupledScalarOrder()

Order ScalarCoupleable::coupledScalarOrder ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns the order for a scalar coupled variable by name.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Order of coupled variable

Definition at line 100 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return _sc_fe_problem.getMaxScalarOrder();

  return getScalarVar(var_name, comp)->order();
}

coupledScalarValue()

const VariableValue & ScalarCoupleable::coupledScalarValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

Definition at line 124 of file ScalarCoupleable.C.

Referenced by ParsedODEKernel::ParsedODEKernel().

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return *getDefaultValue(var_name);

  auto var = getScalarVar(var_name, comp);
  return _sc_is_implicit ? var->sln() : var->slnOld();
}

coupledScalarValueOld()

const VariableValue & ScalarCoupleable::coupledScalarValueOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns the old (previous time step) value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a old VariableValue for the coupled variable

Definition at line 216 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return *getDefaultValue(var_name);

  validateExecutionerType(var_name, "coupledScalarValueOld");
  auto var = getScalarVar(var_name, comp);
  return _sc_is_implicit ? var->slnOld() : var->slnOlder();
}

coupledScalarValueOlder()

const VariableValue & ScalarCoupleable::coupledScalarValueOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedinherited

Returns the older (two time steps previous) value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a older VariableValue for the coupled variable

Definition at line 228 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return *getDefaultValue(var_name);

  validateExecutionerType(var_name, "coupledScalarValueOlder");
  auto var = getScalarVar(var_name, comp);
  if (_sc_is_implicit)
    return var->slnOlder();
  else
    mooseError("Older values not available for explicit schemes");
}

coupledSecond()

const VariableSecond & Coupleable::coupledSecond ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns second spatial derivatives of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableSecond containing the second derivative of the coupled variable

See also

Kernel::second

Definition at line 1726 of file Coupleable.C.

Referenced by NodeElemConstraint::coupledSecondarySecond(), and NodeFaceConstraint::coupledSecondarySecond().

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_second.resize(_coupleable_max_qps);
    return _default_second;
  }
  checkFuncType(var_name, VarType::Second, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->secondSln() : var->secondSlnOlder();
  return (_c_is_implicit) ? var->secondSlnNeighbor() : var->secondSlnOlderNeighbor();
}

coupledSecondOld()

const VariableSecond & Coupleable::coupledSecondOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old second spatial derivatives from previous time step of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableSecond containing the old second derivative of the coupled variable

See also

Kernel::secondOld

Definition at line 1742 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_second.resize(_coupleable_max_qps);
    return _default_second;
  }
  checkFuncType(var_name, VarType::Second, FuncAge::Old);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->secondSlnOld() : var->secondSlnOlder();
  return (_c_is_implicit) ? var->secondSlnOldNeighbor() : var->secondSlnOlderNeighbor();
}

coupledSecondOlder()

const VariableSecond & Coupleable::coupledSecondOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old second derivative from two time steps previous of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableSecond containing the older second derivative of the coupled variable

See also

Kernel::secondOlder

Definition at line 1758 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (!var)
  {
    _default_second.resize(_coupleable_max_qps);
    return _default_second;
  }
  checkFuncType(var_name, VarType::Second, FuncAge::Older);

  if (!_coupleable_neighbor)
    return var->secondSlnOlder();
  return var->secondSlnOlderNeighbor();
}

coupledSecondPreviousNL()

const VariableSecond & Coupleable::coupledSecondPreviousNL ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns second derivative of a coupled variable for the previous Newton iterate.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableSecond containing the second derivative of the coupled variable

Definition at line 1774 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  _c_fe_problem.needsPreviousNewtonIteration(true);
  if (!var)
  {
    _default_second.resize(_coupleable_max_qps);
    return _default_second;
  }
  checkFuncType(var_name, VarType::Second, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return var->secondSlnPreviousNL();
  return var->secondSlnPreviousNLNeighbor();
}

coupledValue()

const VariableValue & Coupleable::coupledValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns value of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

See also

Kernel::_u

Definition at line 482 of file Coupleable.C.

Referenced by NodeElemConstraint::coupledSecondaryValue(), NodeFaceConstraint::coupledSecondaryValue(), Coupleable::coupledValues(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), VariableTimeIntegrationAux::VariableTimeIntegrationAux(), and Coupleable::writableCoupledValue().

{
  const auto * const var = getVarHelper<MooseVariableField<Real>>(var_name, comp);
  if (!var)
    return *getDefaultValue(var_name, comp);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return (_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
    else
      return (_c_is_implicit) ? var->sln() : var->slnOld();
  }
  else
  {
    if (_c_nodal)
      return (_c_is_implicit) ? var->dofValuesNeighbor() : var->dofValuesOldNeighbor();
    else
      return (_c_is_implicit) ? var->slnNeighbor() : var->slnOldNeighbor();
  }
}

coupledValueLower()

const VariableValue & Coupleable::coupledValueLower ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns value of a coupled lower-dimensional variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

Definition at line 587 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (!var)
    return *getDefaultValue(var_name, comp);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  if (_coupleable_neighbor)
    mooseError(_c_name, ":coupledValueLower cannot be called in a coupleable neighbor object");

  if (_c_nodal)
    return (_c_is_implicit) ? var->dofValues() : var->dofValuesOld();
  else
    return (_c_is_implicit) ? var->slnLower() : var->slnLowerOld();
}

coupledValueOld()

const VariableValue & Coupleable::coupledValueOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old value from previous time step of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the old value of the coupled variable

See also

Kernel::valueOld

Definition at line 985 of file Coupleable.C.

Referenced by NodeElemConstraint::coupledSecondaryValueOld(), NodeFaceConstraint::coupledSecondaryValueOld(), Coupleable::coupledValuesOld(), and VariableTimeIntegrationAux::VariableTimeIntegrationAux().

{
  const auto * var = getVar(var_name, comp);
  if (!var)
    return *getDefaultValue(var_name, comp);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Old);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return (_c_is_implicit) ? var->dofValuesOld() : var->dofValuesOlder();
    return (_c_is_implicit) ? var->slnOld() : var->slnOlder();
  }
  else
  {
    if (_c_nodal)
      return (_c_is_implicit) ? var->dofValuesOldNeighbor() : var->dofValuesOlderNeighbor();
    return (_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
  }
}

coupledValueOlder()

const VariableValue & Coupleable::coupledValueOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old value from two time steps previous of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the older value of the coupled variable

See also

Kernel::valueOlder

Definition at line 1007 of file Coupleable.C.

Referenced by NodeElemConstraint::coupledSecondaryValueOlder(), NodeFaceConstraint::coupledSecondaryValueOlder(), Coupleable::coupledValuesOlder(), and VariableTimeIntegrationAux::VariableTimeIntegrationAux().

{
  const auto * var = getVar(var_name, comp);
  if (!var)
    return *getDefaultValue(var_name, comp);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Older);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesOlder();
    return var->slnOlder();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesOlderNeighbor();
    return var->slnOlderNeighbor();
  }
}

coupledValuePreviousNL()

const VariableValue & Coupleable::coupledValuePreviousNL ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns value of previous Newton iterate of a coupled variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue containing the older value of the coupled variable

Definition at line 1029 of file Coupleable.C.

{
  const auto * var = getVar(var_name, comp);
  if (!var)
    return *getDefaultValue(var_name, comp);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  _c_fe_problem.needsPreviousNewtonIteration(true);
  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return var->dofValuesPreviousNL();
    return var->slnPreviousNL();
  }
  else
  {
    if (_c_nodal)
      return var->dofValuesPreviousNLNeighbor();
    return var->slnPreviousNLNeighbor();
  }
}

coupledValues()

std::vector< const VariableValue * > Coupleable::coupledValues ( const std::string &  var_name ) const

protectedinherited

Returns the values for all of a coupled variable components.

Parameters

var_name

Name of coupled variable

Returns

Vector of VariableValue pointers for each component of var_name

Definition at line 2398 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &coupledValue(var_name, comp); };
  return coupledVectorHelper<const VariableValue *>(var_name, func);
}

coupledValuesOld()

std::vector< const VariableValue * > Coupleable::coupledValuesOld ( const std::string &  var_name ) const

protectedinherited

Returns the old values for all of a coupled variable's components.

Parameters

var_name

Name of coupled variable

Returns

Vector of VariableValue pointers for each component of var_name

Definition at line 2579 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &coupledValueOld(var_name, comp); };
  return coupledVectorHelper<const VariableValue *>(var_name, func);
}

coupledValuesOlder()

std::vector< const VariableValue * > Coupleable::coupledValuesOlder ( const std::string &  var_name ) const

protectedinherited

Returns the older values for all of a coupled variable's components.

Parameters

var_name

Name of coupled variable

Returns

Vector of VariableValue pointers for each component of var_name

Definition at line 2586 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &coupledValueOlder(var_name, comp); };
  return coupledVectorHelper<const VariableValue *>(var_name, func);
}

coupledVectorDot()

const VectorVariableValue & Coupleable::coupledVectorDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Time derivative of a coupled vector variable.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a VectorVariableValue containing the time derivative of the coupled variable

Definition at line 1222 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
  {
    _default_vector_value_zero.resize(_coupleable_max_qps);
    return _default_vector_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return var->uDot();
  return var->uDotNeighbor();
}

coupledVectorDotDot()

const VectorVariableValue & Coupleable::coupledVectorDotDot ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Second time derivative of a coupled vector variable.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a VectorVariableValue containing the time derivative of the coupled variable

Definition at line 1238 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
  {
    _default_vector_value_zero.resize(_coupleable_max_qps);
    return _default_vector_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return var->uDotDot();
  return var->uDotDotNeighbor();
}

coupledVectorDotDotDu()

const VariableValue & Coupleable::coupledVectorDotDotDu ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Second time derivative of a coupled vector variable with respect to the coefficients.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a VariableValue containing the time derivative of the coupled vector variable with respect to the coefficients

Definition at line 1302 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
  {
    _default_value_zero.resize(_coupleable_max_qps, 0);
    return _default_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return var->duDotDotDu();
  return var->duDotDotDuNeighbor();
}

coupledVectorDotDotOld()

const VectorVariableValue & Coupleable::coupledVectorDotDotOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Old second time derivative of a coupled vector variable.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a VectorVariableValue containing the time derivative of the coupled variable

Definition at line 1270 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
  {
    _default_vector_value_zero.resize(_coupleable_max_qps);
    return _default_vector_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Old);

  if (!_coupleable_neighbor)
    return var->uDotDotOld();
  return var->uDotDotOldNeighbor();
}

coupledVectorDotDu()

const VariableValue & Coupleable::coupledVectorDotDu ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Time derivative of a coupled vector variable with respect to the coefficients.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a VariableValue containing the time derivative of the coupled vector variable with respect to the coefficients

Definition at line 1286 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
  {
    _default_value_zero.resize(_coupleable_max_qps, 0);
    return _default_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return var->duDotDu();
  return var->duDotDuNeighbor();
}

coupledVectorDotOld()

const VectorVariableValue & Coupleable::coupledVectorDotOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Old time derivative of a coupled vector variable.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a VectorVariableValue containing the time derivative of the coupled variable

Definition at line 1254 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
  {
    _default_vector_value_zero.resize(_coupleable_max_qps);
    return _default_vector_value_zero;
  }
  checkFuncType(var_name, VarType::Dot, FuncAge::Old);

  if (!_coupleable_neighbor)
    return var->uDotOld();
  return var->uDotOldNeighbor();
}

coupledVectorGradient()

const VectorVariableGradient & Coupleable::coupledVectorGradient ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns gradient of a coupled vector variable.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a VectorVariableGradient containing the gradient of the coupled vector variable

Definition at line 1578 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
  {
    _default_vector_gradient.resize(_coupleable_max_qps);
    return _default_vector_gradient;
  }
  checkFuncType(var_name, VarType::Gradient, FuncAge::Curr);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->gradSln() : var->gradSlnOld();
  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
}

coupledVectorGradientOld()

const VectorVariableGradient & Coupleable::coupledVectorGradientOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old gradient from previous time step of a coupled vector variable.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a VectorVariableGradient containing the old gradient of the coupled vector variable

Definition at line 1594 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
  {
    _default_vector_gradient.resize(_coupleable_max_qps);
    return _default_vector_gradient;
  }
  checkFuncType(var_name, VarType::Gradient, FuncAge::Old);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->gradSlnOld() : var->gradSlnOlder();
  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
}

coupledVectorGradientOlder()

const VectorVariableGradient & Coupleable::coupledVectorGradientOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old gradient from two time steps previous of a coupled vector variable.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a VectorVariableGradient containing the older gradient of the coupled vector variable

Definition at line 1610 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
  {
    _default_vector_gradient.resize(_coupleable_max_qps);
    return _default_vector_gradient;
  }
  checkFuncType(var_name, VarType::Gradient, FuncAge::Older);

  if (!_coupleable_neighbor)
    return var->gradSlnOlder();
  return var->gradSlnOlderNeighbor();
}

coupledVectorHelper()

template<typename T , typename Func >

std::vector<T> Coupleable::coupledVectorHelper ( const std::string &  var_name, const Func &  func  ) const

inlineprotectedinherited

Definition at line 1608 of file Coupleable.h.

  {
    const auto components = coupledComponents(var_name);
    std::vector<T> vals(components);
    for (MooseIndex(components) comp = 0; comp < components; ++comp)
      vals[comp] = func(comp);
    return vals;
  }

coupledVectorNeighborGradient()

const VectorVariableGradient & NeighborCoupleable::coupledVectorNeighborGradient ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 239 of file NeighborCoupleable.C.

{
  if (_neighbor_nodal)
    mooseError("Gradients are non-sensical with nodal compute objects");

  const auto * var = getVectorVar(var_name, comp);
  return (_c_is_implicit) ? var->gradSlnNeighbor() : var->gradSlnOldNeighbor();
}

coupledVectorNeighborGradientOld()

const VectorVariableGradient & NeighborCoupleable::coupledVectorNeighborGradientOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 250 of file NeighborCoupleable.C.

{
  if (_neighbor_nodal)
    mooseError("Gradients are non-sensical with nodal compute objects");

  validateExecutionerType(var_name, "coupledVectorNeighborGradientOld");
  const auto * var = getVectorVar(var_name, comp);
  return (_c_is_implicit) ? var->gradSlnOldNeighbor() : var->gradSlnOlderNeighbor();
}

coupledVectorNeighborGradientOlder()

const VectorVariableGradient & NeighborCoupleable::coupledVectorNeighborGradientOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

virtualinherited

Definition at line 262 of file NeighborCoupleable.C.

{
  if (_neighbor_nodal)
    mooseError("Gradients are non-sensical with nodal compute objects");

  validateExecutionerType(var_name, "coupledVectorNeighborGradientOlder");
  const auto * var = getVectorVar(var_name, comp);
  if (_c_is_implicit)
    return var->gradSlnOlderNeighbor();
  else
    mooseError("Older values not available for explicit schemes");
}

coupledVectorTagArrayDofValue()

const ArrayVariableValue & Coupleable::coupledVectorTagArrayDofValue ( const std::string &  var_name, const std::string &  tag_name, unsigned int  comp = 0  ) const

protectedinherited

Returns evaluations of a tagged vector at the requested variable's degree of freedom indices.

Parameters

var_name	Name of coupled variable
tag_name	vector tag name

Returns

Reference to a ArrayVariableValue for the coupled variable

Definition at line 768 of file Coupleable.C.

{
  return vectorTagDofValueHelper<RealEigenVector>(var_name, tag_name, comp);
}

coupledVectorTagArrayGradient() [1/2]

const ArrayVariableGradient & Coupleable::coupledVectorTagArrayGradient ( const std::string &  var_names, TagID  tag, unsigned int  index = 0  ) const

protectedvirtualinherited

Returns gradient of a coupled array variable for a given tag.

Parameters

var_names	Name(s) of coupled array variable(s)
tag	vector tag ID
index	Index of the desired variable in the vector of coupled variables

Returns

Reference to a ArrayVariableGradient containing the gradient of the coupled array variable

See also

Kernel::gradient

Definition at line 674 of file Coupleable.C.

Referenced by Coupleable::coupledVectorTagArrayGradient(), and Coupleable::coupledVectorTagArrayGradients().

{
  const auto * var = getArrayVar(var_names, index);
  if (!var)
    mooseError(var_names, ": invalid variable name for coupledVectorTagArrayGradient");
  checkFuncType(var_names, VarType::Ignore, FuncAge::Curr);

  if (!_c_fe_problem.vectorTagExists(tag))
    mooseError("Attempting to couple to vector tag with ID ",
               tag,
               "in ",
               _c_name,
               ", but a vector tag with that ID does not exist");

  const_cast<Coupleable *>(this)->addFEVariableCoupleableVectorTag(tag);

  return var->vectorTagGradient(tag);
}

coupledVectorTagArrayGradient() [2/2]

const ArrayVariableGradient & Coupleable::coupledVectorTagArrayGradient ( const std::string &  var_names, const std::string &  tag_name, unsigned int  index = 0  ) const

protectedvirtualinherited

Definition at line 696 of file Coupleable.C.

{
  if (!_c_parameters.isParamValid(tag_name))
    mooseError("Tag name parameter '", tag_name, "' is invalid");

  TagName tagname = _c_parameters.get<TagName>(tag_name);
  if (!_c_fe_problem.vectorTagExists(tagname))
    mooseError("Tagged vector with tag name '", tagname, "' does not exist");

  TagID tag = _c_fe_problem.getVectorTagID(tagname);
  return coupledVectorTagArrayGradient(var_names, tag, index);
}

coupledVectorTagArrayGradients() [1/2]

std::vector< const ArrayVariableGradient * > Coupleable::coupledVectorTagArrayGradients ( const std::string &  var_names, TagID  tag  ) const

protectedinherited

Returns gradients for all the coupled variables desired for a given tag.

Parameters

var_names	Name(s) of coupled array variable(s)
tag	vector tag ID

Returns

Vector of ArrayVariableGradient pointers for each variable in var_name

Definition at line 2510 of file Coupleable.C.

Referenced by Coupleable::coupledVectorTagArrayGradients().

{
  auto func = [this, &var_names, &tag](unsigned int index)
  { return &coupledVectorTagArrayGradient(var_names, tag, index); };
  return coupledVectorHelper<const ArrayVariableGradient *>(var_names, func);
}

coupledVectorTagArrayGradients() [2/2]

std::vector< const ArrayVariableGradient * > Coupleable::coupledVectorTagArrayGradients ( const std::string &  var_names, const std::string &  tag_name  ) const

protectedinherited

Definition at line 2518 of file Coupleable.C.

{
  if (!_c_parameters.isParamValid(tag_name))
    mooseError("Tag name parameter '", tag_name, "' is invalid");

  TagName tagname = _c_parameters.get<TagName>(tag_name);
  if (!_c_fe_problem.vectorTagExists(tagname))
    mooseError("Tagged vector with tag name '", tagname, "' does not exist");

  TagID tag = _c_fe_problem.getVectorTagID(tagname);
  return coupledVectorTagArrayGradients(var_names, tag);
}

coupledVectorTagArrayValue() [1/2]

const ArrayVariableValue & Coupleable::coupledVectorTagArrayValue ( const std::string &  var_names, TagID  tag, unsigned int  index = 0  ) const

protectedvirtualinherited

Returns value of a coupled array variable for a given tag.

Parameters

var_names	Name(s) of coupled array variable(s)
tag	vector tag ID
index	Index of the desired variable in the vector of coupled variables

Returns

Reference to a VariableValue for the coupled array variable

See also

Kernel::_u

Definition at line 620 of file Coupleable.C.

Referenced by Coupleable::coupledVectorTagArrayValues().

{
  return vectorTagValueHelper<RealEigenVector>(var_names, tag, index);
}

coupledVectorTagArrayValue() [2/2]

const ArrayVariableValue & Coupleable::coupledVectorTagArrayValue ( const std::string &  var_names, const std::string &  tag_name, unsigned int  index = 0  ) const

protectedvirtualinherited

Definition at line 628 of file Coupleable.C.

{
  return vectorTagValueHelper<RealEigenVector>(var_names, tag_name, index);
}

coupledVectorTagArrayValues() [1/2]

std::vector< const ArrayVariableValue * > Coupleable::coupledVectorTagArrayValues ( const std::string &  var_names, TagID  tag  ) const

protectedinherited

Returns the values for all the coupled variables desired for a given tag.

Parameters

var_name	Name of array coupled variable
tag	vector tag ID

Returns

Vector of ArrayVariableValue pointers for each variable in var_names

Definition at line 2464 of file Coupleable.C.

Referenced by Coupleable::coupledVectorTagArrayValues().

{
  auto func = [this, &var_names, &tag](unsigned int index)
  { return &coupledVectorTagArrayValue(var_names, tag, index); };
  return coupledVectorHelper<const ArrayVariableValue *>(var_names, func);
}

coupledVectorTagArrayValues() [2/2]

std::vector< const ArrayVariableValue * > Coupleable::coupledVectorTagArrayValues ( const std::string &  var_names, const std::string &  tag_name  ) const

protectedinherited

Definition at line 2472 of file Coupleable.C.

{
  if (!_c_parameters.isParamValid(tag_name))
    mooseError("Tag name parameter '", tag_name, "' is invalid");

  TagName tagname = _c_parameters.get<TagName>(tag_name);
  if (!_c_fe_problem.vectorTagExists(tagname))
    mooseError("Tagged vector with tag name '", tagname, "' does not exist");

  TagID tag = _c_fe_problem.getVectorTagID(tagname);
  return coupledVectorTagArrayValues(var_names, tag);
}

coupledVectorTagDofValue() [1/2]

const VariableValue & Coupleable::coupledVectorTagDofValue ( const std::string &  var_name, TagID  tag, unsigned int  index = 0  ) const

protectedvirtualinherited

Returns dof value of a coupled variable for a given tag.

Parameters

var_names	Name(s) of coupled variable(s)
tag	vector tag ID
index	Index of the desired variable in the vector of coupled variables

Returns

Reference to a DofValue for the coupled variable

Definition at line 752 of file Coupleable.C.

Referenced by Coupleable::coupledVectorTagDofValues().

{
  return vectorTagDofValueHelper<Real>(var_name, tag, comp);
}

coupledVectorTagDofValue() [2/2]

const VariableValue & Coupleable::coupledVectorTagDofValue ( const std::string &  var_names, const std::string &  tag_name, unsigned int  index = 0  ) const

protectedvirtualinherited

Definition at line 760 of file Coupleable.C.

{
  return vectorTagDofValueHelper<Real>(var_name, tag_name, comp);
}

coupledVectorTagDofValues() [1/2]

std::vector< const VariableValue * > Coupleable::coupledVectorTagDofValues ( const std::string &  var_names, TagID  tag  ) const

protectedinherited

Returns the dof values for all the coupled variables desired for a given tag.

Parameters

var_names	Name(s) of coupled variable(s)
tag	vector tag ID

Returns

Vector of VariableValue pointers for each variable in var_name

Definition at line 2533 of file Coupleable.C.

Referenced by Coupleable::coupledVectorTagDofValues().

{
  auto func = [this, &var_names, &tag](unsigned int comp)
  { return &coupledVectorTagDofValue(var_names, tag, comp); };
  return coupledVectorHelper<const VariableValue *>(var_names, func);
}

coupledVectorTagDofValues() [2/2]

std::vector< const VariableValue * > Coupleable::coupledVectorTagDofValues ( const std::string &  var_names, const std::string &  tag_name  ) const

protectedinherited

Definition at line 2541 of file Coupleable.C.

{
  if (!_c_parameters.isParamValid(tag_name))
    mooseError("Tag name parameter '", tag_name, "' is invalid");

  TagName tagname = _c_parameters.get<TagName>(tag_name);
  if (!_c_fe_problem.vectorTagExists(tagname))
    mooseError("Tagged vector with tag name '", tagname, "' does not exist");

  TagID tag = _c_fe_problem.getVectorTagID(tagname);
  return coupledVectorTagDofValues(var_names, tag);
}

coupledVectorTagGradient() [1/2]

const VariableGradient & Coupleable::coupledVectorTagGradient ( const std::string &  var_names, TagID  tag, unsigned int  index = 0  ) const

protectedvirtualinherited

Returns gradient of a coupled variable for a given tag.

Parameters

var_names	Name(s) of coupled variable(s)
tag	vector tag ID
index	Index of the desired variable in the vector of coupled variables

Returns

Reference to a VariableGradient containing the gradient of the coupled variable

See also

Kernel::gradient

Definition at line 636 of file Coupleable.C.

Referenced by Coupleable::coupledVectorTagGradient(), and Coupleable::coupledVectorTagGradients().

{
  const auto * var = getVar(var_names, index);
  if (!var)
    mooseError(var_names, ": invalid variable name for coupledVectorTagGradient");
  checkFuncType(var_names, VarType::Ignore, FuncAge::Curr);

  if (!_c_fe_problem.vectorTagExists(tag))
    mooseError("Attempting to couple to vector tag with ID ",
               tag,
               "in ",
               _c_name,
               ", but a vector tag with that ID does not exist");

  const_cast<Coupleable *>(this)->addFEVariableCoupleableVectorTag(tag);

  return var->vectorTagGradient(tag);
}

coupledVectorTagGradient() [2/2]

const VariableGradient & Coupleable::coupledVectorTagGradient ( const std::string &  var_names, const std::string &  tag_name, unsigned int  index = 0  ) const

protectedvirtualinherited

Definition at line 658 of file Coupleable.C.

{
  if (!_c_parameters.isParamValid(tag_name))
    mooseError("Tag name parameter '", tag_name, "' is invalid");

  TagName tagname = _c_parameters.get<TagName>(tag_name);
  if (!_c_fe_problem.vectorTagExists(tagname))
    mooseError("Tagged vector with tag name '", tagname, "' does not exist");

  TagID tag = _c_fe_problem.getVectorTagID(tagname);
  return coupledVectorTagGradient(var_names, tag, index);
}

coupledVectorTagGradients() [1/2]

std::vector< const VariableGradient * > Coupleable::coupledVectorTagGradients ( const std::string &  var_names, TagID  tag  ) const

protectedinherited

Returns gradients for all the coupled variables desired for a given tag.

Parameters

var_names	Name(s) of coupled array variable(s)
tag	vector tag ID

Returns

Vector of VariableGradient pointers for each variables in var_name

Definition at line 2487 of file Coupleable.C.

Referenced by Coupleable::coupledVectorTagGradients().

{
  auto func = [this, &var_names, &tag](unsigned int index)
  { return &coupledVectorTagGradient(var_names, tag, index); };
  return coupledVectorHelper<const VariableGradient *>(var_names, func);
}

coupledVectorTagGradients() [2/2]

std::vector< const VariableGradient * > Coupleable::coupledVectorTagGradients ( const std::string &  var_names, const std::string &  tag_name  ) const

protectedinherited

Definition at line 2495 of file Coupleable.C.

{
  if (!_c_parameters.isParamValid(tag_name))
    mooseError("Tag name parameter '", tag_name, "' is invalid");

  TagName tagname = _c_parameters.get<TagName>(tag_name);
  if (!_c_fe_problem.vectorTagExists(tagname))
    mooseError("Tagged vector with tag name '", tagname, "' does not exist");

  TagID tag = _c_fe_problem.getVectorTagID(tagname);
  return coupledVectorTagGradients(var_names, tag);
}

coupledVectorTagScalarValue()

const VariableValue & ScalarCoupleable::coupledVectorTagScalarValue ( const std::string &  var_name, TagID  tag, unsigned int  comp = 0  ) const

protectedinherited

Returns value of a scalar coupled variable.

Parameters

var_name	Name of coupled variable
tag	Tag ID of coupled vector ;
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

Definition at line 181 of file ScalarCoupleable.C.

{
  checkVar(var_name);
  if (!isCoupledScalar(var_name, comp))
    return *getDefaultValue(var_name);

  if (!_sc_fe_problem.vectorTagExists(tag))
    mooseError("Attempting to couple to vector tag scalar with ID ",
               tag,
               "in ",
               _sc_name,
               ", but a vector tag with that ID does not exist");

  _sc_coupleable_vector_tags.insert(tag);

  return getScalarVar(var_name, comp)->vectorTagSln(tag);
}

coupledVectorTagValue() [1/2]

const VariableValue & Coupleable::coupledVectorTagValue ( const std::string &  var_names, TagID  tag, unsigned int  index = 0  ) const

protectedvirtualinherited

Returns value of a coupled variable for a given tag.

Parameters

var_names	Name(s) of coupled variable(s)
tag	vector tag ID
index	Index of the desired variable in the vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

See also

Kernel::_u

Definition at line 604 of file Coupleable.C.

Referenced by Coupleable::coupledVectorTagValues().

{
  return vectorTagValueHelper<Real>(var_names, tag, index);
}

coupledVectorTagValue() [2/2]

const VariableValue & Coupleable::coupledVectorTagValue ( const std::string &  var_names, const std::string &  tag_name, unsigned int  index = 0  ) const

protectedvirtualinherited

Definition at line 612 of file Coupleable.C.

{
  return vectorTagValueHelper<Real>(var_names, tag_name, index);
}

coupledVectorTagValues() [1/2]

std::vector< const VariableValue * > Coupleable::coupledVectorTagValues ( const std::string &  var_names, TagID  tag  ) const

protectedinherited

Returns the values for all the coupled variables desired for a given tag.

Parameters

var_names	Name(s) of coupled variable(s)
tag	vector tag ID

Returns

Vector of VariableValue pointers for each variable in var_names

Definition at line 2441 of file Coupleable.C.

Referenced by Coupleable::coupledVectorTagValues().

{
  auto func = [this, &var_names, &tag](unsigned int comp)
  { return &coupledVectorTagValue(var_names, tag, comp); };
  return coupledVectorHelper<const VariableValue *>(var_names, func);
}

coupledVectorTagValues() [2/2]

std::vector< const VariableValue * > Coupleable::coupledVectorTagValues ( const std::string &  var_names, const std::string &  tag_name  ) const

protectedinherited

Definition at line 2449 of file Coupleable.C.

{
  if (!_c_parameters.isParamValid(tag_name))
    mooseError("Tag name parameter '", tag_name, "' is invalid");

  TagName tagname = _c_parameters.get<TagName>(tag_name);
  if (!_c_fe_problem.vectorTagExists(tagname))
    mooseError("Tagged vector with tag name '", tagname, "' does not exist");

  TagID tag = _c_fe_problem.getVectorTagID(tagname);
  return coupledVectorTagValues(var_names, tag);
}

coupledVectorValue()

const VectorVariableValue & Coupleable::coupledVectorValue ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns value of a coupled vector variable.

Parameters

var_name	Name of coupled vector variable
comp	Component number for vector of coupled vector variables

Returns

Reference to a VectorVariableValue for the coupled vector variable

See also

VectorKernel::_u

Definition at line 809 of file Coupleable.C.

Referenced by Coupleable::coupledVectorValues().

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
    return *getDefaultVectorValue(var_name);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Curr);

  if (!_coupleable_neighbor)
  {
    if (_c_nodal)
      return _c_is_implicit ? var->nodalValueArray() : var->nodalValueOldArray();
    else
      return _c_is_implicit ? var->sln() : var->slnOld();
  }
  else
  {
    if (_c_nodal)
      // Since this is at a node, I don't feel like there should be any "neighbor" logic
      return _c_is_implicit ? var->nodalValueArray() : var->nodalValueOldArray();
    else
      return _c_is_implicit ? var->slnNeighbor() : var->slnOldNeighbor();
  }
}

coupledVectorValueOld()

const VectorVariableValue & Coupleable::coupledVectorValueOld ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old value from previous time step of a coupled vector variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VectorVariableValue containing the old value of the coupled variable

See also

VectorKernel::_u_old

Definition at line 1052 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
    return *getDefaultVectorValue(var_name);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Old);

  if (!_coupleable_neighbor)
    return (_c_is_implicit) ? var->slnOld() : var->slnOlder();
  return (_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor();
}

coupledVectorValueOlder()

const VectorVariableValue & Coupleable::coupledVectorValueOlder ( const std::string &  var_name, unsigned int  comp = 0  ) const

protectedvirtualinherited

Returns an old value from two time steps previous of a coupled vector variable.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VectorVariableValue containing the older value of the coupled variable

See also

VectorKernel::_u_older

Definition at line 1065 of file Coupleable.C.

{
  const auto * var = getVectorVar(var_name, comp);
  if (!var)
    return *getDefaultVectorValue(var_name);
  checkFuncType(var_name, VarType::Ignore, FuncAge::Older);

  if (!_coupleable_neighbor)
    return var->slnOlder();
  return var->slnOlderNeighbor();
}

coupledVectorValues()

std::vector< const VectorVariableValue * > Coupleable::coupledVectorValues ( const std::string &  var_name ) const

protectedinherited

Returns the values for all of a coupled vector variable's components.

Parameters

var_name

Name of coupled variable

Returns

Vector of VectorVariableValue pointers for each component of var_name

Definition at line 2405 of file Coupleable.C.

{
  auto func = [this, &var_name](unsigned int comp) { return &coupledVectorValue(var_name, comp); };
  return coupledVectorHelper<const VectorVariableValue *>(var_name, func);
}

genericZeroGradient() [1/3]

template<bool is_ad>

const GenericVariableGradient<is_ad>& Coupleable::genericZeroGradient ( )

protectedinherited

Returns zero gradient templated with automatic differentiation boolean.

Returns

Reference to a const GenericVariableValue

genericZeroGradient() [2/3]

template<>

const GenericVariableGradient<false>& Coupleable::genericZeroGradient ( )

protectedinherited

Definition at line 2326 of file Coupleable.C.

{
  return _grad_zero;
}

genericZeroGradient() [3/3]

template<>

const GenericVariableGradient<true>& Coupleable::genericZeroGradient ( )

protectedinherited

Definition at line 2333 of file Coupleable.C.

{
  return _ad_grad_zero;
}

genericZeroSecond() [1/3]

template<bool is_ad>

const GenericVariableSecond<is_ad>& Coupleable::genericZeroSecond ( )

protectedinherited

Returns zero second derivative templated with automatic differentiation boolean.

Returns

Reference to a const GenericVariableValue

genericZeroSecond() [2/3]

template<>

const GenericVariableSecond<false>& Coupleable::genericZeroSecond ( )

protectedinherited

Definition at line 2340 of file Coupleable.C.

{
  return _second_zero;
}

genericZeroSecond() [3/3]

template<>

const GenericVariableSecond<true>& Coupleable::genericZeroSecond ( )

protectedinherited

Definition at line 2347 of file Coupleable.C.

{
  return _ad_second_zero;
}

genericZeroValue() [1/3]

template<bool is_ad>

const GenericVariableValue<is_ad>& Coupleable::genericZeroValue ( )

protectedinherited

Returns zero value templated with automatic differentiation boolean.

Returns

Reference to a const GenericVariableValue

genericZeroValue() [2/3]

template<>

const GenericVariableValue<false>& Coupleable::genericZeroValue ( )

protectedinherited

Definition at line 2312 of file Coupleable.C.

{
  return _zero;
}

genericZeroValue() [3/3]

template<>

const GenericVariableValue<true>& Coupleable::genericZeroValue ( )

protectedinherited

Definition at line 2319 of file Coupleable.C.

{
  return _ad_zero;
}

getADDefaultGradient()

const ADVariableGradient & Coupleable::getADDefaultGradient ( ) const

inherited

Helper method to return (and insert if necessary) the default gradient for Automatic Differentiation for an uncoupled variable.

Parameters

var_name

the name of the variable for which to retrieve a default gradient

Returns

VariableGradient * a pointer to the associated VariableGradient.

Definition at line 2269 of file Coupleable.C.

Referenced by Coupleable::adCoupledGradient(), and Coupleable::adCoupledGradientDot().

{
  _ad_default_gradient.resize(_coupleable_max_qps);
  return _ad_default_gradient;
}

getADDefaultSecond()

const ADVariableSecond & Coupleable::getADDefaultSecond ( ) const

inherited

Helper method to return (and insert if necessary) the default second derivatives for Automatic Differentiation for an uncoupled variable.

Parameters

var_name

the name of the variable for which to retrieve a default second derivative

Returns

VariableSecond * a pointer to the associated VariableSecond.

Definition at line 2283 of file Coupleable.C.

Referenced by Coupleable::adCoupledSecond().

{
  _ad_default_second.resize(_coupleable_max_qps);
  return _ad_default_second;
}

getADDefaultValue()

const ADVariableValue * Coupleable::getADDefaultValue ( const std::string &  var_name ) const

inherited

Helper method to return (and insert if necessary) the default value for Automatic Differentiation for an uncoupled variable.

Parameters

var_name

the name of the variable for which to retrieve a default value

Returns

VariableValue * a pointer to the associated VarirableValue.

Definition at line 2238 of file Coupleable.C.

Referenced by Coupleable::adCoupledDofValues(), Coupleable::adCoupledDot(), Coupleable::adCoupledDotDot(), Coupleable::adCoupledLowerValue(), NeighborCoupleable::adCoupledNeighborValue(), and Coupleable::adCoupledValue().

{
  auto default_value_it = _ad_default_value.find(var_name);
  if (default_value_it == _ad_default_value.end())
  {
    auto value = std::make_unique<ADVariableValue>(_coupleable_max_qps,
                                                   _c_parameters.defaultCoupledValue(var_name));
    default_value_it = _ad_default_value.insert(std::make_pair(var_name, std::move(value))).first;
  }

  return default_value_it->second.get();
}

getADDefaultVectorGradient()

const ADVectorVariableGradient & Coupleable::getADDefaultVectorGradient ( ) const

inherited

Helper method to return (and insert if necessary) the default gradient for Automatic Differentiation for an uncoupled vector variable.

Parameters

var_name

the name of the vector variable for which to retrieve a default gradient

Returns

VariableGradient * a pointer to the associated VectorVariableGradient.

Definition at line 2276 of file Coupleable.C.

Referenced by Coupleable::adCoupledVectorGradient().

{
  _ad_default_vector_gradient.resize(_coupleable_max_qps);
  return _ad_default_vector_gradient;
}

getADDefaultVectorValue()

const ADVectorVariableValue * Coupleable::getADDefaultVectorValue ( const std::string &  var_name ) const

inherited

Helper method to return (and insert if necessary) the default vector value for Automatic Differentiation for an uncoupled variable.

Parameters

var_name

the name of the vector variable for which to retrieve a default value

Returns

VariableVectorValue * a pointer to the associated VarirableVectorValue.

Definition at line 2252 of file Coupleable.C.

Referenced by Coupleable::adCoupledVectorDot(), NeighborCoupleable::adCoupledVectorNeighborValue(), and Coupleable::adCoupledVectorValue().

{
  auto default_value_it = _ad_default_vector_value.find(var_name);
  if (default_value_it == _ad_default_vector_value.end())
  {
    RealVectorValue default_vec;
    for (unsigned int i = 0; i < _c_parameters.numberDefaultCoupledValues(var_name); ++i)
      default_vec(i) = _c_parameters.defaultCoupledValue(var_name, i);
    auto value = std::make_unique<ADVectorVariableValue>(_coupleable_max_qps, default_vec);
    default_value_it =
        _ad_default_vector_value.insert(std::make_pair(var_name, std::move(value))).first;
  }

  return default_value_it->second.get();
}

getArrayVar() [1/2]

ArrayMooseVariable * Coupleable::getArrayVar ( const std::string &  var_name, unsigned int  comp  )

protectedinherited

Extract pointer to a coupled array variable.

Parameters

var_name	Name of parameter desired
comp	Component number of multiple coupled variables

Returns

Pointer to the desired variable

Definition at line 305 of file Coupleable.C.

Referenced by ArrayParsedAux::ArrayParsedAux(), Coupleable::coupledArrayDofValues(), Coupleable::coupledArrayDot(), Coupleable::coupledArrayDotDot(), Coupleable::coupledArrayDotDotOld(), Coupleable::coupledArrayDotDu(), Coupleable::coupledArrayDotOld(), Coupleable::coupledArrayGradient(), Coupleable::coupledArrayGradientDot(), Coupleable::coupledArrayGradientOld(), Coupleable::coupledArrayGradientOlder(), NeighborCoupleable::coupledArrayNeighborGradient(), NeighborCoupleable::coupledArrayNeighborGradientOld(), NeighborCoupleable::coupledArrayNeighborGradientOlder(), NeighborCoupleable::coupledArrayNeighborValue(), Coupleable::coupledArrayValue(), Coupleable::coupledArrayValueOld(), Coupleable::coupledArrayValueOlder(), Coupleable::coupledVectorTagArrayGradient(), TagVectorArrayVariableAux::TagVectorArrayVariableAux(), and TagVectorArrayVariableValueAux::TagVectorArrayVariableValueAux().

{
  return const_cast<ArrayMooseVariable *>(getVarHelper<ArrayMooseVariable>(var_name, comp));
}

getArrayVar() [2/2]

const ArrayMooseVariable * Coupleable::getArrayVar ( const std::string &  var_name, unsigned int  comp  ) const

protectedinherited

Extract pointer to a coupled array variable.

Parameters

var_name	Name of parameter desired
comp	Component number of multiple coupled variables

Returns

Pointer to the desired variable

Definition at line 328 of file Coupleable.C.

{
  return getVarHelper<ArrayMooseVariable>(var_name, comp);
}

getCoupledArrayMooseVars()

const std::vector<ArrayMooseVariable *>& Coupleable::getCoupledArrayMooseVars ( ) const

inlineinherited

Get the list of array coupled variables.

Returns

The list of array coupled variables

Definition at line 97 of file Coupleable.h.

  {
    return _coupled_array_moose_vars;
  }

getCoupledMooseScalarVars()

const std::vector<MooseVariableScalar *>& ScalarCoupleable::getCoupledMooseScalarVars ( )

inlineinherited

Get the list of coupled scalar variables.

Returns

The list of coupled variables

Definition at line 45 of file ScalarCoupleable.h.

Referenced by AuxScalarKernel::AuxScalarKernel(), MortarScalarBase::computeJacobian(), and ScalarInitialCondition::ScalarInitialCondition().

  {
    return _coupled_moose_scalar_vars;
  }

getCoupledMooseVars()

const std::vector<MooseVariableFieldBase *>& Coupleable::getCoupledMooseVars ( ) const

inlineinherited

Get the list of all coupled variables.

Returns

The list of all coupled variables

Definition at line 70 of file Coupleable.h.

Referenced by AuxNodalScalarKernel::AuxNodalScalarKernel(), BuildArrayVariableAux::BuildArrayVariableAux(), CoupleableMooseVariableDependencyIntermediateInterface::CoupleableMooseVariableDependencyIntermediateInterface(), DomainUserObject::DomainUserObject(), ElementIndicator::ElementIndicator(), ElementUserObject::ElementUserObject(), InterfaceMaterial::InterfaceMaterial(), InterfaceUserObjectBase::InterfaceUserObjectBase(), InternalSideIndicator::InternalSideIndicator(), InternalSideUserObject::InternalSideUserObject(), Material::Material(), NeighborCoupleableMooseVariableDependencyIntermediateInterface(), NodalScalarKernel::NodalScalarKernel(), NodalUserObject::NodalUserObject(), and SideUserObject::SideUserObject().

  {
    return _coupled_moose_vars;
  }

getCoupledStandardMooseVars()

const std::vector<MooseVariable *>& Coupleable::getCoupledStandardMooseVars ( ) const

inlineinherited

Get the list of standard coupled variables.

Returns

The list of standard coupled variables

Definition at line 79 of file Coupleable.h.

  {
    return _coupled_standard_moose_vars;
  }

getCoupledVars()

const std::unordered_map<std::string, std::vector<MooseVariableFieldBase *> >& Coupleable::getCoupledVars ( ) const

inlineinherited

Get the list of coupled variables.

Returns

The list of coupled variables

Definition at line 61 of file Coupleable.h.

Referenced by InitialConditionBase::InitialConditionBase().

  {
    return _coupled_vars;
  }

getCoupledVectorMooseVars()

const std::vector<VectorMooseVariable *>& Coupleable::getCoupledVectorMooseVars ( ) const

inlineinherited

Get the list of vector coupled variables.

Returns

The list of vector coupled variables

Definition at line 88 of file Coupleable.h.

  {
    return _coupled_vector_moose_vars;
  }

getFEVar()

const MooseVariableFieldBase * Coupleable::getFEVar ( const std::string &  var_name, unsigned int  comp  ) const

protectedinherited

Deprecated method.

Use getFieldVar instead Extract pointer to a base coupled field variable. Could be either a finite volume or finite element variable

Parameters

var_name	Name of parameter desired
comp	Component number of multiple coupled variables

Returns

Pointer to the desired variable

Definition at line 267 of file Coupleable.C.

{
  mooseDeprecated("Coupleable::getFEVar is deprecated. Please use Coupleable::getFieldVar instead. "
                  "Note that this method could potentially return a finite volume variable");
  return getFieldVar(var_name, comp);
}

getFEVariableCoupleableMatrixTags() [1/2]

std::set<TagID>& Coupleable::getFEVariableCoupleableMatrixTags ( )

inlineinherited

Definition at line 108 of file Coupleable.h.

{ return _fe_coupleable_matrix_tags; }

getFEVariableCoupleableMatrixTags() [2/2]

const std::set<TagID>& Coupleable::getFEVariableCoupleableMatrixTags ( ) const

inlineinherited

Definition at line 115 of file Coupleable.h.

  {
    return _fe_coupleable_matrix_tags;
  }

getFEVariableCoupleableVectorTags() [1/2]

std::set<TagID>& Coupleable::getFEVariableCoupleableVectorTags ( )

inlineinherited

Definition at line 106 of file Coupleable.h.

Referenced by ComputeUserObjectsThread::subdomainChanged(), and MooseObjectWarehouseBase< Indicator >::updateFEVariableCoupledVectorTagDependencyHelper().

{ return _fe_coupleable_vector_tags; }

getFEVariableCoupleableVectorTags() [2/2]

const std::set<TagID>& Coupleable::getFEVariableCoupleableVectorTags ( ) const

inlineinherited

Definition at line 110 of file Coupleable.h.

  {
    return _fe_coupleable_vector_tags;
  }

getFieldVar() [1/2]

const MooseVariableFieldBase * Coupleable::getFieldVar ( const std::string &  var_name, unsigned int  comp  ) const

protectedinherited

Definition at line 281 of file Coupleable.C.

Referenced by ArrayParsedAux::ArrayParsedAux(), Coupleable::coupled(), Coupleable::coupledName(), Coupleable::getFEVar(), DomainUserObject::getInterfaceFieldVar(), InterfaceDiffusiveFluxIntegralTempl< is_ad >::InterfaceDiffusiveFluxIntegralTempl(), InterfaceIntegralVariableValuePostprocessor::InterfaceIntegralVariableValuePostprocessor(), and ParsedAux::ParsedAux().

{
  return getVarHelper<MooseVariableFieldBase>(var_name, comp);
}

getFieldVar() [2/2]

MooseVariableFieldBase * Coupleable::getFieldVar ( const std::string &  var_name, unsigned int  comp  )

protectedinherited

Definition at line 275 of file Coupleable.C.

{
  return getVarHelper<MooseVariableFieldBase>(var_name, comp);
}

getMooseVariableDependencies()

const std::set<MooseVariableFieldBase *>& MooseVariableDependencyInterface::getMooseVariableDependencies ( ) const

inlineinherited

Retrieve the set of MooseVariableFieldBase that this object depends on.

Returns

The MooseVariableFieldBase that MUST be reinited before evaluating this object

Definition at line 35 of file MooseVariableDependencyInterface.h.

Referenced by ComputeUserObjectsThread::subdomainChanged(), and MooseObjectWarehouseBase< Indicator >::updateVariableDependencyHelper().

  {
    return _moose_variable_dependencies;
  }

getScalarVar()

const MooseVariableScalar * ScalarCoupleable::getScalarVar ( const std::string &  var_name, unsigned int  comp  ) const

protectedinherited

Extract pointer to a scalar coupled variable.

Parameters

var_name	Name of parameter desired
comp	Component number of multiple coupled variables

Returns

Pointer to the desired variable

Definition at line 321 of file ScalarCoupleable.C.

Referenced by ScalarCoupleable::adCoupledScalarDot(), ScalarCoupleable::adCoupledScalarValue(), ScalarCoupleable::coupledMatrixTagScalarValue(), ScalarCoupleable::coupledScalar(), ScalarCoupleable::coupledScalarDot(), ScalarCoupleable::coupledScalarDotDot(), ScalarCoupleable::coupledScalarDotDotDu(), ScalarCoupleable::coupledScalarDotDotOld(), ScalarCoupleable::coupledScalarDotDu(), ScalarCoupleable::coupledScalarDotOld(), ScalarCoupleable::coupledScalarOrder(), ScalarCoupleable::coupledScalarValue(), ScalarCoupleable::coupledScalarValueOld(), ScalarCoupleable::coupledScalarValueOlder(), ScalarCoupleable::coupledVectorTagScalarValue(), and ParsedODEKernel::ParsedODEKernel().

{
  const auto var_name = _sc_parameters.checkForRename(var_name_in);

  const auto it = _coupled_scalar_vars.find(var_name);
  if (it != _coupled_scalar_vars.end())
  {
    const auto & entry = it->second;
    if (comp < entry.size())
      return entry[comp];
    else
      mooseError(_sc_name, ": Trying to get a non-existent component of variable '", var_name, "'");
  }
  else
    mooseError(_sc_name, ": Trying to get a non-existent variable '", var_name, "'");
}

getScalarVariableCoupleableMatrixTags()

const std::set<TagID>& ScalarCoupleable::getScalarVariableCoupleableMatrixTags ( ) const

inlineinherited

Definition at line 55 of file ScalarCoupleable.h.

  {
    return _sc_coupleable_matrix_tags;
  }

getScalarVariableCoupleableVectorTags()

const std::set<TagID>& ScalarCoupleable::getScalarVariableCoupleableVectorTags ( ) const

inlineinherited

Definition at line 50 of file ScalarCoupleable.h.

  {
    return _sc_coupleable_vector_tags;
  }

getVar() [1/2]

MooseVariable * Coupleable::getVar ( const std::string &  var_name, unsigned int  comp  )

protectedinherited

Extract pointer to a coupled variable.

Parameters

var_name	Name of parameter desired
comp	Component number of multiple coupled variables

Returns

Pointer to the desired variable

Definition at line 287 of file Coupleable.C.

Referenced by Coupleable::coupledDofValuesOld(), Coupleable::coupledDofValuesOlder(), Coupleable::coupledDot(), Coupleable::coupledDotDot(), Coupleable::coupledDotDotDu(), Coupleable::coupledDotDotOld(), Coupleable::coupledDotDu(), Coupleable::coupledDotOld(), Coupleable::coupledGradientDot(), Coupleable::coupledGradientDotDot(), Coupleable::coupledGradientOld(), Coupleable::coupledGradientOlder(), Coupleable::coupledGradientPreviousNL(), NeighborCoupleable::coupledNeighborDofValues(), NeighborCoupleable::coupledNeighborDofValuesOld(), NeighborCoupleable::coupledNeighborDofValuesOlder(), NeighborCoupleable::coupledNeighborGradientOld(), NeighborCoupleable::coupledNeighborGradientOlder(), NeighborCoupleable::coupledNeighborSecond(), NeighborCoupleable::coupledNeighborValueDot(), NeighborCoupleable::coupledNeighborValueDotDu(), NeighborCoupleable::coupledNeighborValueOld(), NeighborCoupleable::coupledNeighborValueOlder(), Coupleable::coupledNodalDotDot(), Coupleable::coupledNodalDotDotOld(), Coupleable::coupledNodalDotOld(), Coupleable::coupledSecond(), Coupleable::coupledSecondOld(), Coupleable::coupledSecondOlder(), Coupleable::coupledSecondPreviousNL(), Coupleable::coupledValueLower(), Coupleable::coupledValueOld(), Coupleable::coupledValueOlder(), Coupleable::coupledValuePreviousNL(), Coupleable::coupledVectorTagGradient(), ExtraIDIntegralVectorPostprocessor::ExtraIDIntegralVectorPostprocessor(), and Coupleable::writableCoupledValue().

{
  return const_cast<MooseVariable *>(getVarHelper<MooseVariable>(var_name, comp));
}

getVar() [2/2]

const MooseVariable * Coupleable::getVar ( const std::string &  var_name, unsigned int  comp  ) const

protectedinherited

Extract pointer to a coupled variable.

Parameters

var_name	Name of parameter desired
comp	Component number of multiple coupled variables

Returns

Pointer to the desired variable

Definition at line 311 of file Coupleable.C.

{
  return getVarHelper<MooseVariable>(var_name, comp);
}

getVarHelper() [1/2]

template<typename T >

const T * Coupleable::getVarHelper ( const std::string &  var_name, unsigned int  comp  ) const

protectedinherited

Helper that that be used to retrieve a variable of arbitrary type T.

Definition at line 1777 of file Coupleable.h.

{
  return const_cast<Coupleable *>(this)->getVarHelper<T>(var_name, comp);
}

getVarHelper() [2/2]

template<typename T >

T * Coupleable::getVarHelper ( const std::string &  var_name, unsigned int  comp  )

protectedinherited

Helper that can be used to retrieve a variable of arbitrary type T.

Definition at line 1723 of file Coupleable.h.

{
  const auto var_name = _c_parameters.checkForRename(var_name_in);
  auto name_to_use = var_name;

  // First check for supplied name
  if (!checkVar(var_name, comp, 0))
  {
    // See if there is an associated deprecated name that the user may have used instead
    auto it = _new_to_deprecated_coupled_vars.find(var_name);
    if (it == _new_to_deprecated_coupled_vars.end())
      return nullptr;
    else
    {
      auto deprecated_name = it->second;
      if (checkVar(deprecated_name, comp, 0))
        name_to_use = deprecated_name;
      else
        return nullptr;
    }
  }

  auto coupled_vars_it = _coupled_vars.find(name_to_use);

  mooseAssert(coupled_vars_it != _coupled_vars.end(),
              "Trying to get a coupled var " << name_to_use << " that doesn't exist");

  if (auto coupled_var = dynamic_cast<T *>(coupled_vars_it->second[comp]))
    return coupled_var;
  else
  {
    for (auto & var : _coupled_standard_moose_vars)
      if (var->name() == name_to_use)
        mooseError("The named variable is a standard variable, try a "
                   "'coupled[Value/Gradient/Dot/etc]...' function instead");
    for (auto & var : _coupled_vector_moose_vars)
      if (var->name() == name_to_use)
        mooseError("The named variable is a vector variable, try a "
                   "'coupledVector[Value/Gradient/Dot/etc]...' function instead");
    for (auto & var : _coupled_array_moose_vars)
      if (var->name() == name_to_use)
        mooseError("The named variable is an array variable, try a "
                   "'coupledArray[Value/Gradient/Dot/etc]...' function instead");
    for (auto & var : _coupled_standard_fv_moose_vars)
      if (var->name() == name_to_use)
        mooseError("The named variable is a finite volume variable, which the coupled[...] routine "
                   "used does not support. Try using the functor system routines instead.");
    mooseError(
        "Variable '", name_to_use, "' is of a different C++ type than you tried to fetch it as.");
  }
}

getVectorVar() [1/2]

VectorMooseVariable * Coupleable::getVectorVar ( const std::string &  var_name, unsigned int  comp  )

protectedinherited

Extract pointer to a coupled vector variable.

Parameters

var_name	Name of parameter desired
comp	Component number of multiple coupled variables

Returns

Pointer to the desired variable

Definition at line 293 of file Coupleable.C.

Referenced by Coupleable::adCoupledVectorDot(), Coupleable::adCoupledVectorGradient(), Coupleable::adCoupledVectorValue(), Coupleable::coupledCurl(), Coupleable::coupledCurlOld(), Coupleable::coupledCurlOlder(), Coupleable::coupledVectorDot(), Coupleable::coupledVectorDotDot(), Coupleable::coupledVectorDotDotDu(), Coupleable::coupledVectorDotDotOld(), Coupleable::coupledVectorDotDu(), Coupleable::coupledVectorDotOld(), Coupleable::coupledVectorGradient(), Coupleable::coupledVectorGradientOld(), Coupleable::coupledVectorGradientOlder(), NeighborCoupleable::coupledVectorNeighborGradient(), NeighborCoupleable::coupledVectorNeighborGradientOld(), NeighborCoupleable::coupledVectorNeighborGradientOlder(), Coupleable::coupledVectorValue(), Coupleable::coupledVectorValueOld(), and Coupleable::coupledVectorValueOlder().

{
  auto * const var =
      const_cast<VectorMooseVariable *>(getVarHelper<VectorMooseVariable>(var_name, comp));

  if (_c_nodal && var && var->feType().family != LAGRANGE_VEC)
    mooseError(_c_name, ": Only LAGRANGE_VEC vector variables are defined at nodes");

  return var;
}

getVectorVar() [2/2]

const VectorMooseVariable * Coupleable::getVectorVar ( const std::string &  var_name, unsigned int  comp  ) const

protectedinherited

Extract pointer to a coupled vector variable.

Parameters

var_name	Name of parameter desired
comp	Component number of multiple coupled variables

Returns

Pointer to the desired variable

Definition at line 317 of file Coupleable.C.

{
  const auto * const var = getVarHelper<VectorMooseVariable>(var_name, comp);

  if (_c_nodal && var && var->feType().family != LAGRANGE_VEC)
    mooseError(_c_name, ": Only LAGRANGE_VEC vector variables are defined at nodes");

  return var;
}

getWritableCoupledVariables()

auto& Coupleable::getWritableCoupledVariables ( ) const

inlineinherited

returns a reference to the set of writable coupled variables

Definition at line 123 of file Coupleable.h.

Referenced by Coupleable::hasWritableCoupledVariables().

{ return _writable_coupled_variables[_c_tid]; }

hasWritableCoupledVariables()

bool Coupleable::hasWritableCoupledVariables ( ) const

inlineinherited

Checks whether the object has any writable coupled variables.

Definition at line 128 of file Coupleable.h.

{ return !getWritableCoupledVariables().empty(); }

isCoupled()

bool Coupleable::isCoupled ( const std::string &  var_name, unsigned int  i = 0  ) const

protectedvirtualinherited

Returns true if a variables has been coupled as name.

Parameters

var_name	The name the kernel wants to refer to the variable as.
i	By default 0, in general the index to test in a vector of MooseVariable pointers.

Returns

True if a coupled variable has the supplied name

Definition at line 128 of file Coupleable.C.

Referenced by Coupleable::adCoupledNodalValue(), Coupleable::checkVar(), Coupleable::coupledComponents(), and MatDiffusionBase< Real >::MatDiffusionBase().

{
  const auto var_name = _c_parameters.checkForRename(var_name_in);

  auto it = _coupled_vars.find(var_name);
  if (it != _coupled_vars.end())
    return (i < it->second.size());
  else
  {
    // Make sure the user originally requested this value in the InputParameter syntax
    if (!_c_parameters.hasCoupledValue(var_name))
      mooseError(_c_name,
                 ": The coupled variable \"",
                 var_name,
                 "\" was never added to this object's "
                 "InputParameters, please double-check your "
                 "spelling");

    return false;
  }
}

isCoupledConstant()

bool Coupleable::isCoupledConstant ( const std::string &  var_name ) const

protectedvirtualinherited

Returns true if a variable passed as a coupled value is really a constant.

Parameters

var_name

The name the kernel wants to refer to the variable as.

Returns

True if the variable is actually a constant

Definition at line 151 of file Coupleable.C.

Referenced by Coupleable::coupledName(), and DerivativeFunctionMaterialBaseTempl< is_ad >::DerivativeFunctionMaterialBaseTempl().

{
  return _c_parameters.hasDefaultCoupledValue(var_name);
}

isCoupledScalar()

bool ScalarCoupleable::isCoupledScalar ( const std::string &  var_name, unsigned int  i = 0  ) const

protectedinherited

Returns true if a variables has been coupled_as name.

Parameters

var_name	The of the coupled variable
i	By default 0, in general the index to test in a vector of MooseVariable pointers.

Definition at line 70 of file ScalarCoupleable.C.

Referenced by ScalarCoupleable::adCoupledScalarValue(), ScalarCoupleable::coupledMatrixTagScalarValue(), ScalarCoupleable::coupledScalarOrder(), ScalarCoupleable::coupledScalarValue(), ScalarCoupleable::coupledScalarValueOld(), ScalarCoupleable::coupledScalarValueOlder(), and ScalarCoupleable::coupledVectorTagScalarValue().

{
  const auto var_name = _sc_parameters.checkForRename(var_name_in);

  auto it = _coupled_scalar_vars.find(var_name);
  if (it != _coupled_scalar_vars.end())
    return (i < it->second.size());
  else
  {
    // Make sure the user originally requested this value in the InputParameter syntax
    if (!_sc_parameters.hasCoupledValue(var_name))
      mooseError(_sc_name,
                 ": The coupled scalar variable \"",
                 var_name,
                 "\" was never added to this object's "
                 "InputParameters, please double-check "
                 "your spelling");

    return false;
  }
}

validateExecutionerType()

void Coupleable::validateExecutionerType ( const std::string &  name, const std::string &  fn_name  ) const

protectedinherited

Checks to make sure that the current Executioner has set "_is_transient" when old/older values are coupled in.

Parameters

name	the name of the variable
fn_name	The name of the function that called this method - used in the error message

Definition at line 2021 of file Coupleable.C.

Referenced by Coupleable::checkFuncType(), NeighborCoupleable::coupledArrayNeighborGradientOld(), NeighborCoupleable::coupledArrayNeighborGradientOlder(), NeighborCoupleable::coupledNeighborDofValuesOld(), NeighborCoupleable::coupledNeighborDofValuesOlder(), NeighborCoupleable::coupledNeighborGradientOld(), NeighborCoupleable::coupledNeighborGradientOlder(), NeighborCoupleable::coupledNeighborValueOld(), NeighborCoupleable::coupledNeighborValueOlder(), NeighborCoupleable::coupledVectorNeighborGradientOld(), and NeighborCoupleable::coupledVectorNeighborGradientOlder().

{
  if (!_c_fe_problem.isTransient())
    mooseError(_c_name,
               ": Calling \"",
               fn_name,
               "\" on variable \"",
               name,
               "\" when using a \"Steady\" executioner is not allowed. This value is available "
               "only in transient simulations.");
}

validParams()

static InputParameters NeighborCoupleableMooseVariableDependencyIntermediateInterface::validParams ( )

inlinestatic

Definition at line 28 of file NeighborCoupleableMooseVariableDependencyIntermediateInterface.h.

Referenced by FVInterfaceKernel::validParams().

{ return emptyInputParameters(); }

writableCoupledValue()

VariableValue & Coupleable::writableCoupledValue ( const std::string &  var_name, unsigned int  comp = 0  )

protectedvirtualinherited

Returns a writable reference to a coupled variable for writing to multiple AuxVariables from a single AuxKernel or a UserObject.

Only one object can obtain a writable reference in a simulation.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a VariableValue for the coupled variable

See also

Kernel::value

Definition at line 898 of file Coupleable.C.

{
  mooseDeprecated("Coupleable::writableCoupledValue is deprecated, please use "
                  "Coupleable::writableVariable instead. ");

  // check if the variable exists
  auto * const var = getVar(var_name, comp);
  if (!var)
    mooseError(
        "Unable to create a writable reference for '", var_name, "', is it a constant expression?");

  // is the requested variable an AuxiliaryVariable?
  if (!_c_fe_problem.getAuxiliarySystem().hasVariable(var->name()))
    mooseError(
        "'", var->name(), "' must be an auxiliary variable in Coupleable::writableCoupledValue");

  // check that the variable type (elemental/nodal) is compatible with the object type
  const auto * aux = dynamic_cast<const AuxKernel *>(this);

  if (!aux)
    mooseError("writableCoupledValue() can only be called from AuxKernels, but '",
               _obj->name(),
               "' is not an AuxKernel.");

  if (!aux->isNodal() && var->isNodal())
    mooseError("The elemental AuxKernel '",
               _obj->name(),
               "' cannot obtain a writable reference to the nodal variable '",
               var->name(),
               "'.");

  // make sure only one object can access a variable
  checkWritableVar(var);

  return const_cast<VariableValue &>(coupledValue(var_name, comp));
}

writableVariable()

MooseWritableVariable & Coupleable::writableVariable ( const std::string &  var_name, unsigned int  comp = 0  )

protectedinherited

Returns a writable MooseVariable object for a nodal or elemental variable.

Use var.setNodalValue(val[, idx]) in both cases (!) to set the solution DOF values. Only one object can obtain a writable reference in a simulation. Note that the written values will not ba available in the same system loop! E.g. values written using this API by a nodal AuxKernel will not be updated for other nodal AuxKernels during the same iteration over all nodes.

Parameters

var_name	Name of coupled variable
comp	Component number for vector of coupled variables

Returns

Reference to a MooseWritableVariable for the coupled variable

See also

Kernel::value

Definition at line 863 of file Coupleable.C.

{
  auto * var = getVarHelper<MooseWritableVariable>(var_name, comp);

  const auto * aux = dynamic_cast<const AuxKernel *>(this);
  const auto * euo = dynamic_cast<const ElementUserObject *>(this);
  const auto * nuo = dynamic_cast<const NodalUserObject *>(this);
  const auto * nfc = dynamic_cast<const NodeFaceConstraint *>(this);

  if (!aux && !euo && !nuo && !nfc)
    mooseError("writableVariable() can only be called from AuxKernels, ElementUserObjects, "
               "NodalUserObjects, or NodeFaceConstraints. '",
               _obj->name(),
               "' is none of those.");

  if (aux && !aux->isNodal() && var->isNodal())
    mooseError("The elemental AuxKernel '",
               _obj->name(),
               "' cannot obtain a writable reference to the nodal variable '",
               var->name(),
               "'.");
  if (euo && var->isNodal())
    mooseError("The ElementUserObject '",
               _obj->name(),
               "' cannot obtain a writable reference to the nodal variable '",
               var->name(),
               "'.");

  // make sure only one object can access a variable
  checkWritableVar(var);

  return *var;
}

Member Data Documentation

_ad_default_gradient

MooseArray<ADRealVectorValue> Coupleable::_ad_default_gradient

mutableprotectedinherited

This will always be zero because the default values for optionally coupled variables is always constant.

Definition at line 1388 of file Coupleable.h.

Referenced by Coupleable::getADDefaultGradient().

_ad_default_second

MooseArray<ADRealTensorValue> Coupleable::_ad_default_second

mutableprotectedinherited

This will always be zero because the default values for optionally coupled variables is always constant.

Definition at line 1397 of file Coupleable.h.

Referenced by Coupleable::getADDefaultSecond().

_ad_default_value

std::unordered_map<std::string, std::unique_ptr<MooseArray<DualReal> > > Coupleable::_ad_default_value

mutableprotectedinherited

Will hold the default value for optional coupled variables for automatic differentiation.

Definition at line 1365 of file Coupleable.h.

Referenced by Coupleable::getADDefaultValue().

_ad_default_vector_gradient

MooseArray<ADRealTensorValue> Coupleable::_ad_default_vector_gradient

mutableprotectedinherited

This will always be zero because the default values for optionally coupled vector variables is always constant.

Definition at line 1391 of file Coupleable.h.

Referenced by Coupleable::getADDefaultVectorGradient().

_ad_default_vector_value

std::unordered_map<std::string, std::unique_ptr<MooseArray<ADRealVectorValue> > > Coupleable::_ad_default_vector_value

mutableprotectedinherited

Will hold the default value for optional vector coupled variables for automatic differentiation.

Definition at line 1376 of file Coupleable.h.

Referenced by Coupleable::getADDefaultVectorValue().

_ad_grad_zero

const MooseArray<ADRealVectorValue>& Coupleable::_ad_grad_zero

protectedinherited

Definition at line 1406 of file Coupleable.h.

Referenced by Coupleable::adZeroGradient().

_ad_second_zero

const MooseArray<ADRealTensorValue>& Coupleable::_ad_second_zero

protectedinherited

Definition at line 1413 of file Coupleable.h.

Referenced by Coupleable::adZeroSecond().

_ad_zero

const MooseArray<DualReal>& Coupleable::_ad_zero

protectedinherited

Definition at line 1402 of file Coupleable.h.

Referenced by Coupleable::adZeroValue().

_c_allow_element_to_nodal_coupling

const bool Coupleable::_c_allow_element_to_nodal_coupling

protectedinherited

Definition at line 1355 of file Coupleable.h.

Referenced by Coupleable::checkVar().

_c_fe_problem

FEProblemBase& Coupleable::_c_fe_problem

protectedinherited

Definition at line 1319 of file Coupleable.h.

Referenced by Coupleable::coupledGradientPreviousNL(), Coupleable::coupledMatrixTagValue(), Coupleable::coupledMatrixTagValues(), Coupleable::coupledNodalValuePreviousNL(), Coupleable::coupledSecondPreviousNL(), Coupleable::coupledValuePreviousNL(), Coupleable::coupledVectorTagArrayGradient(), Coupleable::coupledVectorTagArrayGradients(), Coupleable::coupledVectorTagArrayValues(), Coupleable::coupledVectorTagDofValues(), Coupleable::coupledVectorTagGradient(), Coupleable::coupledVectorTagGradients(), Coupleable::coupledVectorTagValues(), Coupleable::validateExecutionerType(), Coupleable::vectorTagDofValueHelper(), Coupleable::vectorTagValueHelper(), and Coupleable::writableCoupledValue().

_c_is_implicit

bool Coupleable::_c_is_implicit

protectedinherited

True if implicit value is required.

Definition at line 1352 of file Coupleable.h.

Referenced by Coupleable::adCoupledDofValues(), Coupleable::adCoupledGradient(), Coupleable::adCoupledGradientDot(), Coupleable::adCoupledLowerValue(), NeighborCoupleable::adCoupledNeighborGradient(), NeighborCoupleable::adCoupledNeighborValue(), NeighborCoupleable::adCoupledNeighborValueDot(), Coupleable::adCoupledNodalValue(), Coupleable::adCoupledSecond(), Coupleable::adCoupledValue(), Coupleable::adCoupledVectorGradient(), NeighborCoupleable::adCoupledVectorNeighborValue(), Coupleable::adCoupledVectorValue(), Coupleable::checkFuncType(), Coupleable::coupledArrayDofValues(), Coupleable::coupledArrayGradient(), Coupleable::coupledArrayGradientOld(), NeighborCoupleable::coupledArrayNeighborGradient(), NeighborCoupleable::coupledArrayNeighborGradientOld(), NeighborCoupleable::coupledArrayNeighborGradientOlder(), NeighborCoupleable::coupledArrayNeighborValue(), Coupleable::coupledArrayValue(), Coupleable::coupledArrayValueOld(), Coupleable::coupledCurl(), Coupleable::coupledCurlOld(), Coupleable::coupledDofValues(), Coupleable::coupledDofValuesOld(), Coupleable::coupledGradient(), Coupleable::coupledGradientOld(), NeighborCoupleable::coupledNeighborDofValues(), NeighborCoupleable::coupledNeighborDofValuesOld(), NeighborCoupleable::coupledNeighborDofValuesOlder(), NeighborCoupleable::coupledNeighborGradient(), NeighborCoupleable::coupledNeighborGradientOld(), NeighborCoupleable::coupledNeighborGradientOlder(), NeighborCoupleable::coupledNeighborSecond(), NeighborCoupleable::coupledNeighborValue(), NeighborCoupleable::coupledNeighborValueOld(), NeighborCoupleable::coupledNeighborValueOlder(), Coupleable::coupledNodalValue(), Coupleable::coupledNodalValueOld(), Coupleable::coupledSecond(), Coupleable::coupledSecondOld(), Coupleable::coupledValue(), Coupleable::coupledValueLower(), Coupleable::coupledValueOld(), Coupleable::coupledVectorGradient(), Coupleable::coupledVectorGradientOld(), NeighborCoupleable::coupledVectorNeighborGradient(), NeighborCoupleable::coupledVectorNeighborGradientOld(), NeighborCoupleable::coupledVectorNeighborGradientOlder(), Coupleable::coupledVectorValue(), and Coupleable::coupledVectorValueOld().

_c_name

const std::string& Coupleable::_c_name

protectedinherited

The name of the object this interface is part of.

Definition at line 1314 of file Coupleable.h.

Referenced by Coupleable::checkFuncType(), Coupleable::checkVar(), Coupleable::coupledName(), Coupleable::coupledNodalValue(), Coupleable::coupledNodalValueOld(), Coupleable::coupledNodalValueOlder(), Coupleable::coupledValueLower(), Coupleable::coupledVectorTagArrayGradient(), Coupleable::coupledVectorTagGradient(), Coupleable::getVectorVar(), Coupleable::isCoupled(), Coupleable::validateExecutionerType(), and Coupleable::vectorTagValueHelper().

_c_nodal

bool Coupleable::_c_nodal

protectedinherited

True if we provide coupling to nodal values.

Definition at line 1349 of file Coupleable.h.

Referenced by Coupleable::adCoupledDot(), Coupleable::adCoupledDotDot(), Coupleable::adCoupledLowerValue(), Coupleable::adCoupledNodalValue(), Coupleable::adCoupledValue(), Coupleable::adCoupledVectorDot(), Coupleable::adCoupledVectorValue(), Coupleable::checkFuncType(), Coupleable::checkVar(), Coupleable::coupledArrayDot(), Coupleable::coupledArrayDotDot(), Coupleable::coupledArrayDotDotOld(), Coupleable::coupledArrayDotDu(), Coupleable::coupledArrayDotOld(), Coupleable::coupledArrayValue(), Coupleable::coupledArrayValueOld(), Coupleable::coupledArrayValueOlder(), Coupleable::coupledDot(), Coupleable::coupledDotDot(), Coupleable::coupledDotDotDu(), Coupleable::coupledDotDotOld(), Coupleable::coupledDotDu(), Coupleable::coupledDotOld(), Coupleable::coupledMatrixTagValue(), Coupleable::coupledValue(), Coupleable::coupledValueLower(), Coupleable::coupledValueOld(), Coupleable::coupledValueOlder(), Coupleable::coupledValuePreviousNL(), Coupleable::coupledVectorValue(), Coupleable::getVectorVar(), and Coupleable::vectorTagValueHelper().

_c_parameters

const InputParameters& Coupleable::_c_parameters

protectedinherited

Definition at line 1311 of file Coupleable.h.

Referenced by Coupleable::checkVar(), Coupleable::Coupleable(), Coupleable::coupledComponents(), Coupleable::coupledMatrixTagValue(), Coupleable::coupledMatrixTagValues(), Coupleable::coupledVectorTagArrayGradient(), Coupleable::coupledVectorTagArrayGradients(), Coupleable::coupledVectorTagArrayValues(), Coupleable::coupledVectorTagDofValues(), Coupleable::coupledVectorTagGradient(), Coupleable::coupledVectorTagGradients(), Coupleable::coupledVectorTagValues(), Coupleable::getADDefaultValue(), Coupleable::getADDefaultVectorValue(), Coupleable::getDefaultArrayValue(), Coupleable::getDefaultValue(), Coupleable::getDefaultVectorValue(), Coupleable::getVarHelper(), Coupleable::isCoupled(), Coupleable::isCoupledConstant(), Coupleable::vectorTagDofValueHelper(), and Coupleable::vectorTagValueHelper().

_c_sys

const SystemBase* const Coupleable::_c_sys

protectedinherited

Pointer to the system object if the moose object this is an interface for has one.

Definition at line 1322 of file Coupleable.h.

Referenced by Coupleable::coupled().

_c_tid

THREAD_ID Coupleable::_c_tid

protectedinherited

Thread ID of the thread using this object.

Definition at line 1358 of file Coupleable.h.

Referenced by Coupleable::checkWritableVar(), Coupleable::Coupleable(), and Coupleable::getWritableCoupledVariables().

_c_type

const std::string& Coupleable::_c_type

protectedinherited

The type of the object this interface is part of.

Definition at line 1316 of file Coupleable.h.

_coupleable_neighbor

bool Coupleable::_coupleable_neighbor

protectedinherited

Whether or not this object is a "neighbor" object: ie all of it's coupled values should be neighbor values.

Definition at line 1618 of file Coupleable.h.

Referenced by Coupleable::adCoupledDofValues(), Coupleable::adCoupledDot(), Coupleable::adCoupledDotDot(), Coupleable::adCoupledGradient(), Coupleable::adCoupledGradientDot(), Coupleable::adCoupledNodalValue(), Coupleable::adCoupledSecond(), Coupleable::adCoupledValue(), Coupleable::adCoupledVectorDot(), Coupleable::adCoupledVectorGradient(), Coupleable::adCoupledVectorValue(), Coupleable::coupledArrayDofValues(), Coupleable::coupledArrayDot(), Coupleable::coupledArrayDotDot(), Coupleable::coupledArrayDotDotOld(), Coupleable::coupledArrayDotDu(), Coupleable::coupledArrayDotOld(), Coupleable::coupledArrayGradient(), Coupleable::coupledArrayGradientDot(), Coupleable::coupledArrayGradientOld(), Coupleable::coupledArrayGradientOlder(), Coupleable::coupledArrayValue(), Coupleable::coupledArrayValueOld(), Coupleable::coupledArrayValueOlder(), Coupleable::coupledCurl(), Coupleable::coupledCurlOld(), Coupleable::coupledCurlOlder(), Coupleable::coupledDofValues(), Coupleable::coupledDofValuesOld(), Coupleable::coupledDofValuesOlder(), Coupleable::coupledDot(), Coupleable::coupledDotDot(), Coupleable::coupledDotDotDu(), Coupleable::coupledDotDotOld(), Coupleable::coupledDotDu(), Coupleable::coupledDotOld(), Coupleable::coupledGradient(), Coupleable::coupledGradientDot(), Coupleable::coupledGradientDotDot(), Coupleable::coupledGradientOld(), Coupleable::coupledGradientOlder(), Coupleable::coupledGradientPreviousNL(), Coupleable::coupledNodalDot(), Coupleable::coupledNodalDotDot(), Coupleable::coupledNodalDotDotOld(), Coupleable::coupledNodalDotOld(), Coupleable::coupledNodalValue(), Coupleable::coupledNodalValueOld(), Coupleable::coupledNodalValueOlder(), Coupleable::coupledNodalValuePreviousNL(), Coupleable::coupledSecond(), Coupleable::coupledSecondOld(), Coupleable::coupledSecondOlder(), Coupleable::coupledSecondPreviousNL(), Coupleable::coupledValue(), Coupleable::coupledValueLower(), Coupleable::coupledValueOld(), Coupleable::coupledValueOlder(), Coupleable::coupledValuePreviousNL(), Coupleable::coupledVectorDot(), Coupleable::coupledVectorDotDot(), Coupleable::coupledVectorDotDotDu(), Coupleable::coupledVectorDotDotOld(), Coupleable::coupledVectorDotDu(), Coupleable::coupledVectorDotOld(), Coupleable::coupledVectorGradient(), Coupleable::coupledVectorGradientOld(), Coupleable::coupledVectorGradientOlder(), Coupleable::coupledVectorValue(), Coupleable::coupledVectorValueOld(), and Coupleable::coupledVectorValueOlder().

_coupled_array_moose_vars

std::vector<ArrayMooseVariable *> Coupleable::_coupled_array_moose_vars

protectedinherited

Vector of array coupled variables.

Definition at line 1337 of file Coupleable.h.

Referenced by Coupleable::Coupleable(), Coupleable::getCoupledArrayMooseVars(), and Coupleable::getVarHelper().

_coupled_moose_vars

std::vector<MooseVariableFieldBase *> Coupleable::_coupled_moose_vars

protectedinherited

Vector of all coupled variables.

Definition at line 1328 of file Coupleable.h.

Referenced by Coupleable::Coupleable(), ElementValueSampler::ElementValueSampler(), SideValueSampler::execute(), ElementValueSampler::execute(), PointVariableSamplerBase::execute(), Coupleable::getCoupledMooseVars(), PointVariableSamplerBase::initialize(), InterfaceUserObject::InterfaceUserObject(), MatDiffusionBase< Real >::MatDiffusionBase(), MaterialDerivativeTestKernelBase< Real >::MaterialDerivativeTestKernelBase(), NodalValueSampler::NodalValueSampler(), PointVariableSamplerBase::PointVariableSamplerBase(), and SideValueSampler::SideValueSampler().

_coupled_standard_fv_moose_vars

std::vector<MooseVariableFV<Real> *> Coupleable::_coupled_standard_fv_moose_vars

protectedinherited

Vector of standard finite volume coupled variables.

Definition at line 1340 of file Coupleable.h.

Referenced by Coupleable::Coupleable(), ElementValueSampler::execute(), and Coupleable::getVarHelper().

_coupled_standard_linear_fv_moose_vars

std::vector<MooseLinearVariableFV<Real> *> Coupleable::_coupled_standard_linear_fv_moose_vars

protectedinherited

Vector of standard linear finite volume coupled variables.

Definition at line 1343 of file Coupleable.h.

Referenced by Coupleable::Coupleable().

_coupled_standard_moose_vars

std::vector<MooseVariable *> Coupleable::_coupled_standard_moose_vars

protectedinherited

Vector of standard coupled variables.

Definition at line 1331 of file Coupleable.h.

Referenced by Coupleable::Coupleable(), NodalValueSampler::execute(), ElementValueSampler::execute(), Coupleable::getCoupledStandardMooseVars(), and Coupleable::getVarHelper().

_coupled_vars

std::unordered_map<std::string, std::vector<MooseVariableFieldBase *> > Coupleable::_coupled_vars

protectedinherited

Coupled vars whose values we provide.

Definition at line 1325 of file Coupleable.h.

Referenced by Coupleable::checkVar(), Coupleable::Coupleable(), Coupleable::coupledComponents(), FunctionMaterialBase< is_ad >::FunctionMaterialBase(), Coupleable::getCoupledVars(), Coupleable::getVarHelper(), and Coupleable::isCoupled().

_coupled_vector_moose_vars

std::vector<VectorMooseVariable *> Coupleable::_coupled_vector_moose_vars

protectedinherited

Vector of vector coupled variables.

Definition at line 1334 of file Coupleable.h.

Referenced by Coupleable::Coupleable(), Coupleable::getCoupledVectorMooseVars(), and Coupleable::getVarHelper().

_default_array_curl

ArrayVariableCurl Coupleable::_default_array_curl

protectedinherited

This will always be zero because the default values for optionally coupled variables is always constant.

Definition at line 1443 of file Coupleable.h.

_default_array_gradient

ArrayVariableGradient Coupleable::_default_array_gradient

protectedinherited

This will always be zero because the default values for optionally coupled variables is always constant.

Definition at line 1440 of file Coupleable.h.

Referenced by Coupleable::coupledArrayGradient(), Coupleable::coupledArrayGradientDot(), Coupleable::coupledArrayGradientOld(), and Coupleable::coupledArrayGradientOlder().

_default_array_value

std::unordered_map<std::string, std::unique_ptr<ArrayVariableValue> > Coupleable::_default_array_value

mutableprotectedinherited

Will hold the default value for optional array coupled variables.

Definition at line 1372 of file Coupleable.h.

Referenced by Coupleable::getDefaultArrayValue().

_default_array_value_zero

ArrayVariableValue Coupleable::_default_array_value_zero

protectedinherited

This will always be zero because the default values for optionally coupled variables is always constant and this is used for time derivative info.

Definition at line 1437 of file Coupleable.h.

Referenced by Coupleable::coupledArrayDot(), Coupleable::coupledArrayDotDot(), Coupleable::coupledArrayDotDotOld(), and Coupleable::coupledArrayDotOld().

_default_gradient

VariableGradient Coupleable::_default_gradient

mutableprotectedinherited

This will always be zero because the default values for optionally coupled variables is always constant.

Definition at line 1385 of file Coupleable.h.

Referenced by Coupleable::coupledGradient(), Coupleable::coupledGradientDot(), Coupleable::coupledGradientDotDot(), Coupleable::coupledGradientOld(), Coupleable::coupledGradientOlder(), and Coupleable::coupledGradientPreviousNL().

_default_second

VariableSecond Coupleable::_default_second

mutableprotectedinherited

This will always be zero because the default values for optionally coupled variables is always constant.

Definition at line 1394 of file Coupleable.h.

Referenced by Coupleable::coupledSecond(), Coupleable::coupledSecondOld(), Coupleable::coupledSecondOlder(), and Coupleable::coupledSecondPreviousNL().

_default_value

std::unordered_map<std::string, std::vector<std::unique_ptr<VariableValue> > > Coupleable::_default_value

mutableprotectedinherited

Will hold the default value for optional coupled variables.

Definition at line 1362 of file Coupleable.h.

Referenced by Coupleable::getDefaultValue().

_default_value_zero

VariableValue Coupleable::_default_value_zero

mutableprotectedinherited

This will always be zero because the default values for optionally coupled variables is always constant and this is used for time derivative info.

Definition at line 1382 of file Coupleable.h.

Referenced by Coupleable::coupledArrayDotDu(), Coupleable::coupledDot(), Coupleable::coupledDotDot(), Coupleable::coupledDotDotDu(), Coupleable::coupledDotDotOld(), Coupleable::coupledDotDu(), Coupleable::coupledDotOld(), Coupleable::coupledNodalDotDot(), Coupleable::coupledNodalDotDotOld(), Coupleable::coupledNodalDotOld(), Coupleable::coupledVectorDotDotDu(), and Coupleable::coupledVectorDotDu().

_default_vector_curl

VectorVariableCurl Coupleable::_default_vector_curl

mutableprotectedinherited

This will always be zero because the default values for optionally coupled variables is always constant.

Definition at line 1431 of file Coupleable.h.

Referenced by Coupleable::coupledCurl(), Coupleable::coupledCurlOld(), and Coupleable::coupledCurlOlder().

_default_vector_gradient

VectorVariableGradient Coupleable::_default_vector_gradient

mutableprotectedinherited

This will always be zero because the default values for optionally coupled variables is always constant.

Definition at line 1428 of file Coupleable.h.

Referenced by Coupleable::coupledVectorGradient(), Coupleable::coupledVectorGradientOld(), and Coupleable::coupledVectorGradientOlder().

_default_vector_value

std::unordered_map<std::string, std::unique_ptr<VectorVariableValue> > Coupleable::_default_vector_value

mutableprotectedinherited

Will hold the default value for optional vector coupled variables.

Definition at line 1369 of file Coupleable.h.

Referenced by Coupleable::getDefaultVectorValue().

_default_vector_value_zero

VectorVariableValue Coupleable::_default_vector_value_zero

mutableprotectedinherited

This will always be zero because the default values for optionally coupled variables is always constant and this is used for time derivative info.

Definition at line 1425 of file Coupleable.h.

Referenced by Coupleable::coupledVectorDot(), Coupleable::coupledVectorDotDot(), Coupleable::coupledVectorDotDotOld(), and Coupleable::coupledVectorDotOld().

_grad_phi_zero

const VariablePhiGradient& Coupleable::_grad_phi_zero

protectedinherited

Zero gradient of trial function.

Definition at line 1409 of file Coupleable.h.

_grad_zero

const VariableGradient& Coupleable::_grad_zero

protectedinherited

Zero gradient of a variable.

Definition at line 1405 of file Coupleable.h.

_neighbor_nodal

bool NeighborCoupleable::_neighbor_nodal

protectedinherited

Definition at line 131 of file NeighborCoupleable.h.

Referenced by NeighborCoupleable::adCoupledNeighborGradient(), NeighborCoupleable::adCoupledNeighborValue(), NeighborCoupleable::adCoupledNeighborValueDot(), NeighborCoupleable::adCoupledVectorNeighborValue(), NeighborCoupleable::coupledArrayNeighborGradient(), NeighborCoupleable::coupledArrayNeighborGradientOld(), NeighborCoupleable::coupledArrayNeighborGradientOlder(), NeighborCoupleable::coupledArrayNeighborValue(), NeighborCoupleable::coupledNeighborDofValues(), NeighborCoupleable::coupledNeighborDofValuesOld(), NeighborCoupleable::coupledNeighborDofValuesOlder(), NeighborCoupleable::coupledNeighborGradient(), NeighborCoupleable::coupledNeighborGradientOld(), NeighborCoupleable::coupledNeighborGradientOlder(), NeighborCoupleable::coupledNeighborSecond(), NeighborCoupleable::coupledNeighborValue(), NeighborCoupleable::coupledNeighborValueDot(), NeighborCoupleable::coupledNeighborValueDotDu(), NeighborCoupleable::coupledNeighborValueOld(), NeighborCoupleable::coupledNeighborValueOlder(), NeighborCoupleable::coupledVectorNeighborGradient(), NeighborCoupleable::coupledVectorNeighborGradientOld(), and NeighborCoupleable::coupledVectorNeighborGradientOlder().

_new_to_deprecated_coupled_vars

const std::unordered_map<std::string, std::string>& Coupleable::_new_to_deprecated_coupled_vars

protectedinherited

map from new to deprecated variable names

Definition at line 1346 of file Coupleable.h.

Referenced by Coupleable::getVarHelper().

_phi_zero

const VariablePhiValue& Coupleable::_phi_zero

protectedinherited

Definition at line 1401 of file Coupleable.h.

_point_zero

const Point& ScalarCoupleable::_point_zero

protectedinherited

Zero point.

Definition at line 244 of file ScalarCoupleable.h.

Referenced by FunctionDT::computeDT(), FunctionScalarAux::computeValue(), and FunctionScalarIC::value().

_real_zero

const Real& ScalarCoupleable::_real_zero

protectedinherited

Scalar zero.

Definition at line 238 of file ScalarCoupleable.h.

_sc_fe_problem

FEProblemBase& ScalarCoupleable::_sc_fe_problem

protectedinherited

Definition at line 232 of file ScalarCoupleable.h.

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

_sc_tid

const THREAD_ID ScalarCoupleable::_sc_tid

protectedinherited

Thread ID of the thread using this object.

Definition at line 235 of file ScalarCoupleable.h.

Referenced by ScalarCoupleable::ScalarCoupleable().

_scalar_zero

const VariableValue& ScalarCoupleable::_scalar_zero

protectedinherited

Zero value of a scalar variable.

Definition at line 241 of file ScalarCoupleable.h.

_second_phi_zero

const VariablePhiSecond& Coupleable::_second_phi_zero

protectedinherited

Zero second derivative of a test function.

Definition at line 1415 of file Coupleable.h.

_second_zero

const VariableSecond& Coupleable::_second_zero

protectedinherited

Zero second derivative of a variable.

Definition at line 1412 of file Coupleable.h.

_vector_curl_zero

const VectorVariableCurl& Coupleable::_vector_curl_zero

protectedinherited

Zero value of the curl of a vector variable.

Definition at line 1419 of file Coupleable.h.

_vector_zero

const VectorVariableValue& Coupleable::_vector_zero

protectedinherited

Zero value of a vector variable.

Definition at line 1417 of file Coupleable.h.

_zero

const VariableValue& Coupleable::_zero

protectedinherited

Zero value of a variable.

Definition at line 1400 of file Coupleable.h.

---

The documentation for this class was generated from the following file:

• include/variables/NeighborCoupleableMooseVariableDependencyIntermediateInterface.h