MooseVariableData< OutputType > Class Template Reference

#include <MooseVariableData.h>

Inheritance diagram for MooseVariableData< OutputType >:

Public Types
typedef MooseArray< OutputSecond >	FieldVariableSecond
typedef MooseArray< OutputType >	FieldVariableCurl
typedef MooseArray< OutputDivergence >	FieldVariableDivergence
typedef Moose::ShapeType< OutputType >::type	OutputShape
typedef libMesh::TensorTools::IncrementRank< OutputShape >::type	OutputShapeGradient
typedef libMesh::TensorTools::IncrementRank< OutputShapeGradient >::type	OutputShapeSecond
typedef libMesh::TensorTools::DecrementRank< OutputShape >::type	OutputShapeDivergence
typedef MooseArray< std::vector< OutputShape > >	FieldVariablePhiValue
typedef MooseArray< std::vector< OutputShapeGradient > >	FieldVariablePhiGradient
typedef MooseArray< std::vector< OutputShapeSecond > >	FieldVariablePhiSecond
typedef MooseArray< std::vector< OutputShape > >	FieldVariablePhiCurl
typedef MooseArray< std::vector< OutputShapeDivergence > >	FieldVariablePhiDivergence
typedef MooseArray< std::vector< OutputShape > >	FieldVariableTestValue
typedef MooseArray< std::vector< OutputShapeGradient > >	FieldVariableTestGradient
typedef MooseArray< std::vector< OutputShapeSecond > >	FieldVariableTestSecond
typedef MooseArray< std::vector< OutputShape > >	FieldVariableTestCurl
typedef MooseArray< std::vector< OutputShapeDivergence > >	FieldVariableTestDivergence
typedef libMesh::TensorTools::IncrementRank< OutputType >::type	OutputGradient
typedef libMesh::TensorTools::IncrementRank< OutputGradient >::type	OutputSecond
typedef libMesh::TensorTools::DecrementRank< OutputType >::type	OutputDivergence
typedef MooseArray< OutputType >	FieldVariableValue
typedef MooseArray< OutputGradient >	FieldVariableGradient
typedef Moose::DOFType< OutputType >::type	DofValue
typedef Moose::ADType< DofValue >::type	ADDofValue
typedef MooseArray< DofValue >	DofValues
typedef MooseArray< ADDofValue >	ADDofValues

Public Member Functions
	MooseVariableData (const MooseVariableFE< OutputType > &var, SystemBase &sys, THREAD_ID tid, Moose::ElementType element_type, const QBase *const &qrule_in, const QBase *const &qrule_face_in, const Node *const &node, const Elem *const &elem)
bool	needsAD () const
	Returns whether this data structure needs automatic differentiation calculations. More...
void	setGeometry (Moose::GeometryType gm_type)
	Set the geometry type before calculating variables values. More...
void	computeValues ()
	compute the variable values More...
void	computeConstantMonomialValues ()
	compute the values for const monomial variables More...
template<bool constant_monomial>
void	computeAD (const unsigned int num_dofs, const unsigned int nqp)
	compute AD things More...
void	computeNodalValues ()
	compute nodal things More...
const FieldVariablePhiValue &	phi () const
	phi getter More...
const FieldVariablePhiValue &	phiFace () const
	phi_face getter More...
const FieldVariablePhiGradient &	gradPhi () const
	grad_phi getter More...
const MappedArrayVariablePhiGradient &	arrayGradPhi () const
	mapped_grad_phi getter More...
const FieldVariablePhiGradient &	gradPhiFace () const
	grad_phi_face getter More...
const MappedArrayVariablePhiGradient &	arrayGradPhiFace () const
	mapped_grad_phi_face getter More...
const FieldVariablePhiSecond &	secondPhi () const
	second_phi getter More...
const FieldVariablePhiSecond &	secondPhiFace () const
	second_phi_face getter More...
const FieldVariablePhiCurl &	curlPhi () const
	curl_phi getter More...
const FieldVariablePhiCurl &	curlPhiFace () const
	curl_phi_face getter More...
const FieldVariablePhiDivergence &	divPhi () const
	divergence_phi getter More...
const FieldVariablePhiDivergence &	divPhiFace () const
	divergence_phi_face getter More...
const ADTemplateVariablePhiGradient< OutputShape > &	adGradPhi () const
	ad_grad_phi getter More...
const ADTemplateVariablePhiGradient< OutputShape > &	adGradPhiFace () const
	ad_grad_phi_face getter More...
std::size_t	phiSize () const
	Return phi size. More...
std::size_t	phiFaceSize () const
	Return phiFace size. More...
bool	usesSecondPhi () const
	Whether or not this variable is computing any second derivatives. More...
bool	computingCurl () const
	Whether or not this variable is computing the curl. More...
bool	computingDiv () const
	Whether or not this variable is computing the divergence. More...
bool	isNodal () const override
bool	hasDoFsOnNodes () const override
	Whether this data is associated with a variable that has DoFs on nodes. More...
libMesh::FEContinuity	getContinuity () const override
	Return the variable continuity. More...
const Node *const &	node () const
const dof_id_type &	nodalDofIndex () const
bool	isNodalDefined () const
const Elem *const &	currentElem () const
	The current element. More...
const unsigned int &	currentSide () const
	The current side. More...
void	prepareIC ()
	prepare the initial condition More...
const FieldVariableGradient &	gradSlnDot () const
	Local time derivative of solution gradient getter. More...
const FieldVariableGradient &	gradSlnDotDot () const
	Local second time derivative of solution gradient getter. More...
const FieldVariableSecond &	secondSln (Moose::SolutionState state) const
	Local solution second spatial derivative getter. More...
const FieldVariableCurl &	curlSln (Moose::SolutionState state) const
	Local solution curl getter. More...
const FieldVariableDivergence &	divSln (Moose::SolutionState state) const
	Local solution divergence getter. More...
const ADTemplateVariableValue< OutputType > &	adSln () const
const ADTemplateVariableGradient< OutputType > &	adGradSln () const
const ADTemplateVariableGradient< OutputType > &	adGradSlnDot () const
const ADTemplateVariableSecond< OutputType > &	adSecondSln () const
const ADTemplateVariableValue< OutputType > &	adUDot () const
const ADTemplateVariableValue< OutputType > &	adUDotDot () const
const FieldVariableValue &	uDot () const
const FieldVariableValue &	uDotDot () const
const FieldVariableValue &	uDotOld () const
const FieldVariableValue &	uDotDotOld () const
const VariableValue &	duDotDu () const
const VariableValue &	duDotDotDu () const
const ADTemplateVariableCurl< OutputType > &	adCurlSln () const
const OutputType &	nodalValueDot () const
const OutputType &	nodalValueDotDot () const
const OutputType &	nodalValueDotOld () const
const OutputType &	nodalValueDotDotOld () const
const OutputType &	nodalValueDuDotDu () const
const OutputType &	nodalValueDuDotDotDu () const
const Moose::ADType< OutputType >::type &	adNodalValue () const
void	setDofValues (const DenseVector< DofValue > &values)
	Set local DOF values and evaluate the values on quadrature points. More...
void	insertNodalValue (libMesh::NumericVector< libMesh::Number > &residual, const DofValue &v)
	Write a nodal value to the passed-in solution vector. More...
DofValue	getNodalValue (const Node &node, Moose::SolutionState state) const
DofValue	getElementalValue (const Elem *elem, Moose::SolutionState state, unsigned int idx=0) const
void	getDofIndices (const Elem *elem, std::vector< dof_id_type > &dof_indices) const
const std::vector< dof_id_type > &	dofIndices () const
unsigned int	numberOfDofs () const
void	clearDofIndices ()
void	prepare ()
	Get the dof indices corresponding to the current element. More...
void	reinitNode ()
	Prepare degrees of freedom for the current node. More...
void	reinitAux ()
	Prepare dof indices and solution values for elemental auxiliary variables. More...
void	reinitNodes (const std::vector< dof_id_type > &nodes)
	Set _dof_indices to the degrees of freedom existing on the passed-in nodes. More...
void	addSolution (libMesh::NumericVector< libMesh::Number > &sol, const DenseVector< libMesh::Number > &v) const
	Add passed in local DOF values to a solution vector. More...
const DofValues &	dofValuesDot () const
const DofValues &	dofValuesDotOld () const
const DofValues &	dofValuesDotDot () const
const DofValues &	dofValuesDotDotOld () const
const MooseArray< libMesh::Number > &	dofValuesDuDotDu () const
const MooseArray< libMesh::Number > &	dofValuesDuDotDotDu () const
const ADDofValues &	adDofValues () const
	Return the AD dof values. More...
const ADDofValues &	adDofValuesDot () const
	Return the AD time derivative values of degrees of freedom. More...
const FieldVariableValue &	increment () const
	Increment getter. More...
void	computeIncrementAtQps (const libMesh::NumericVector< libMesh::Number > &increment_vec)
	Compute and store incremental change in solution at QPs based on increment_vec. More...
void	computeIncrementAtNode (const libMesh::NumericVector< libMesh::Number > &increment_vec)
	Compute and store incremental change at the current node based on increment_vec. More...
template<>
void	insertNodalValue (NumericVector< Number > &residual, const RealEigenVector &v)
template<>
RealEigenVector	getNodalValue (const Node &node, Moose::SolutionState state) const
template<>
RealEigenVector	getElementalValue (const Elem *elem, const Moose::SolutionState state, const unsigned int idx) const
template<>
void	computeIncrementAtQps (const NumericVector< Number > &increment_vec)
template<>
void	computeIncrementAtNode (const NumericVector< Number > &increment_vec)
const FieldVariableValue &	sln (Moose::SolutionState state) const
	Local solution getter. More...
const FieldVariableGradient &	gradSln (Moose::SolutionState state) const
	Local solution gradient getter. More...
unsigned int	oldestSolutionStateRequested () const
	The oldest solution state that is requested for this variable (0 = current, 1 = old, 2 = older, etc). More...
void	setNodalValue (const OutputType &value, unsigned int idx=0)
	Set nodal value. More...
template<>
void	setNodalValue (const RealVectorValue &value, unsigned int idx)
void	insert (libMesh::NumericVector< libMesh::Number > &residual)
	Set the current local DOF values to the input vector. More...
template<>
void	insert (NumericVector< Number > &residual)
void	add (libMesh::NumericVector< libMesh::Number > &residual)
	Add the current local DOF values to the input vector. More...
template<>
void	add (NumericVector< Number > &residual)
const DofValues &	dofValues () const
const DofValues &	dofValuesOld () const
const DofValues &	dofValuesOlder () const
const DofValues &	dofValuesPreviousNL () const
const OutputType &	nodalValue (Moose::SolutionState state) const
const MooseArray< OutputType > &	nodalValueArray (Moose::SolutionState state) const
const FieldVariableValue &	vectorTagValue (TagID tag) const
const FieldVariableGradient &	vectorTagGradient (TagID tag) const
const FieldVariableValue &	matrixTagValue (TagID tag) const
const DofValues &	nodalVectorTagValue (TagID tag) const
const DofValues &	nodalMatrixTagValue (TagID tag) const
const DofValues &	vectorTagDofValue (TagID tag) const
const DofValues &	vectorTagDofValue (Moose::SolutionState state) const
void	setActiveTags (const std::set< TagID > &vtags)
	Set the active vector tags. More...
void	prepareAux ()
	Clear aux state. More...
void	sizeMatrixTagData ()
	size matrix tag data More...
void	setDofValue (const DofValue &value, unsigned int index)
	dof value setters More...

Protected Member Functions
virtual const MooseVariableField< OutputType > &	var () const
void	insertSolutionTag (TagID tag_id)
	insert a solution tag into our tag containers More...
void	needSolutionState (unsigned int state)
	Request that we have at least state number of older solution states/vectors. More...
void	fetchDofValues ()
	Helper methods for assigning dof values from their corresponding solution values. More...
template<>
void	fetchDofValues ()
template<>
void	fetchDofValues ()
void	zeroSizeDofValues ()
void	getArrayDofValues (const libMesh::NumericVector< libMesh::Number > &sol, unsigned int n, MooseArray< RealEigenVector > &dof_values) const
void	assignNodalValue ()
template<>
void	assignNodalValue ()
template<>
void	assignNodalValue ()
template<typename ReturnType , typename Functor >
const ReturnType &	stateToTagHelper (Moose::SolutionState state, Functor functor)
	Helper method that converts a SolutionState argument into a corresponding tag ID, potentially requesting necessary additional solution states and assigning tag id data members, and then calls the provided functor with the tag ID. More...
void	resizeVectorTagData (TagID tag)
	resize the vector tag need flags and data containers to accomodate this tag index More...

Protected Attributes
SystemBase &	_sys
	The MOOSE system which ultimately holds the vectors and matrices relevant to this variable data. More...
const SubProblem &	_subproblem
	The subproblem which we can query for information related to tagged vectors and matrices. More...
const THREAD_ID	_tid
	The thread ID that this object is on. More...
const libMesh::DofMap &	_dof_map
	The degree of freedom map from libMesh. More...
unsigned int	_count
	Number of components of the associated variable. More...
bool	_has_dof_values
	Whether we currently have degree of freedom values stored in our local containers (corresponding to the current element) More...
unsigned int	_max_state
	The maximum number of older solution states our variable needs. More...
TagID	_solution_tag
	The vector tag ID corresponding to the solution vector. More...
TagID	_old_solution_tag
	The vector tag ID corresponding to the old solution vector. More...
TagID	_older_solution_tag
	The vector tag ID corresponding to the older solution vector. More...
TagID	_previous_nl_solution_tag
	The vector tag ID corresponding to the previous nonlinear iteration's solution vector. More...
std::vector< dof_id_type >	_dof_indices
	The dof indices for the current element. More...
std::vector< bool >	_need_vector_tag_dof_u
std::vector< bool >	_need_matrix_tag_dof_u
std::vector< DofValues >	_vector_tags_dof_u
std::vector< DofValues >	_matrix_tags_dof_u
std::vector< FieldVariableValue >	_vector_tag_u
std::vector< bool >	_need_vector_tag_u
std::vector< FieldVariableGradient >	_vector_tag_grad
std::vector< bool >	_need_vector_tag_grad
std::vector< FieldVariableValue >	_matrix_tag_u
std::vector< bool >	_need_matrix_tag_u
OutputType	_nodal_value
	Nodal values. More...
OutputType	_nodal_value_old
OutputType	_nodal_value_older
OutputType	_nodal_value_previous_nl
MooseArray< OutputType >	_nodal_value_array
	Nodal values as MooseArrays for use with AuxKernels. More...
MooseArray< OutputType >	_nodal_value_old_array
MooseArray< OutputType >	_nodal_value_older_array
bool	_need_u_dot
	u dot flags More...
bool	_need_u_dotdot
bool	_need_u_dot_old
bool	_need_u_dotdot_old
bool	_need_du_dot_du
bool	_need_du_dotdot_du
bool	_need_grad_dot
	gradient dot flags More...
bool	_need_grad_dotdot
bool	_need_dof_values_dot
	local solution flags More...
bool	_need_dof_values_dotdot
bool	_need_dof_values_dot_old
bool	_need_dof_values_dotdot_old
bool	_need_dof_du_dot_du
bool	_need_dof_du_dotdot_du
DofValues	_dof_values_dot
	time derivative of the solution values More...
DofValues	_dof_values_dotdot
	second time derivative of the solution values More...
DofValues	_dof_values_dot_old
	the previous time step's solution value time derivative More...
DofValues	_dof_values_dotdot_old
	the previous time step's solution value second time derivative More...
MooseArray< libMesh::Number >	_dof_du_dot_du
	derivatives of the solution value time derivative with respect to the degrees of freedom More...
MooseArray< libMesh::Number >	_dof_du_dotdot_du
	derivatives of the solution value second time derivative with respect to the degrees of freedom More...
OutputType	_nodal_value_dot
	nodal values of u_dot More...
OutputType	_nodal_value_dotdot
	nodal values of u_dotdot More...
OutputType	_nodal_value_dot_old
	nodal values of u_dot_old More...
OutputType	_nodal_value_dotdot_old
	nodal values of u_dotdot_old More...
std::set< TagID >	_required_vector_tags
	The set of vector tags (residual + solution) we need to evaluate. More...
std::set< TagID >	_solution_tags
	The set of solution tags we need to evaluate. More...

Private Member Functions
void	fetchADDofValues ()
	Helper method for assigning the ad_dof* arrays. More...
void	assignADNodalValue ()
	Helper method for assigning nodal values from their corresponding solution values (dof values as they're referred to here in this class). More...
template<bool constant_monomial>
void	computeValuesInternal ()
	Internal method for computeValues() and computeConstantMonomialValues() More...
template<bool constant_monomial, typename DestinationType , typename ShapeType , typename DofValuesType >
void	fill (DestinationType &dest, const ShapeType &phi, const DofValuesType &dof_values, unsigned int nqp, std::size_t num_shapes)
template<>
void	fetchADDofValues ()
template<>
void	assignADNodalValue ()

Private Attributes
const MooseVariableFE< OutputType > &	_var
	A const reference to the owning MooseVariableFE object. More...
const libMesh::FEType &	_fe_type
const unsigned int	_var_num
const Assembly &	_assembly
Moose::ElementType	_element_type
	The element type this object is storing data for. This is either Element, Neighbor, or Lower. More...
bool	_is_nodal
	if variable is nodal More...
dof_id_type	_nodal_dof_index
	The dof index for the current node. More...
libMesh::FEContinuity	_continuity
	Continuity type of the variable. More...
FieldVariableValue	_increment
	Increment in the variable used in dampers. More...
Moose::ADType< OutputType >::type	_ad_nodal_value
	AD nodal value. More...
ADReal	_ad_zero
	A zero AD variable. More...
bool	_need_second = false
	SolutionState second_u flags. More...
bool	_need_second_old = false
bool	_need_second_older = false
bool	_need_second_previous_nl = false
bool	_need_curl = false
	curl flags More...
bool	_need_curl_old = false
bool	_need_curl_older = false
bool	_need_div = false
	divergence flags More...
bool	_need_div_old = false
bool	_need_div_older = false
bool	_need_ad = false
	AD flags. More...
bool	_need_ad_u = false
bool	_need_ad_grad_u = false
bool	_need_ad_grad_u_dot = false
bool	_need_ad_second_u = false
bool	_need_ad_curl_u = false
bool	_need_ad_div_u = false
bool	_need_ad_u_dot = false
bool	_need_ad_u_dotdot = false
bool	_has_dof_indices
FieldVariableGradient	_grad_u_dot
	grad_u dots More...
FieldVariableGradient	_grad_u_dotdot
FieldVariableSecond	_second_u
	second_u More...
FieldVariableSecond	_second_u_old
FieldVariableSecond	_second_u_older
FieldVariableSecond	_second_u_previous_nl
FieldVariableCurl	_curl_u
	curl_u More...
FieldVariableCurl	_curl_u_old
FieldVariableCurl	_curl_u_older
FieldVariableDivergence	_div_u
	divergence_u More...
FieldVariableDivergence	_div_u_old
FieldVariableDivergence	_div_u_older
ADTemplateVariableValue< OutputType >	_ad_u
	AD u. More...
ADTemplateVariableGradient< OutputType >	_ad_grad_u
ADTemplateVariableSecond< OutputType >	_ad_second_u
ADDofValues	_ad_dof_values
ADDofValues	_ad_dofs_dot
MooseArray< ADRealEigenVector >	_ad_dofs_dot_eigen
ADDofValues	_ad_dofs_dotdot
MooseArray< ADRealEigenVector >	_ad_dofs_dotdot_eigen
ADTemplateVariableValue< OutputType >	_ad_u_dot
ADTemplateVariableValue< OutputType >	_ad_u_dotdot
ADTemplateVariableGradient< OutputType >	_ad_grad_u_dot
ADTemplateVariableCurl< OutputType >	_ad_curl_u
FieldVariableValue	_u_dot
	u_dot (time derivative) More...
FieldVariableValue	_u_dotdot
	u_dotdot (second time derivative) More...
FieldVariableValue	_u_dot_old
	u_dot_old (time derivative) More...
FieldVariableValue	_u_dotdot_old
	u_dotdot_old (second time derivative) More...
VariableValue	_du_dot_du
	derivative of u_dot wrt u More...
VariableValue	_du_dotdot_du
	derivative of u_dotdot wrt u More...
const QBase *const &	_qrule
	The current qrule. More...
const QBase *const &	_qrule_face
const FieldVariablePhiValue *	_phi
const FieldVariablePhiGradient *	_grad_phi
const FieldVariablePhiSecond *	_second_phi
const FieldVariablePhiCurl *	_curl_phi
const FieldVariablePhiDivergence *	_div_phi
MappedArrayVariablePhiGradient	_mapped_grad_phi
MappedArrayVariablePhiGradient	_mapped_grad_phi_face
MappedArrayVariablePhiGradient	_mapped_grad_phi_neighbor
MappedArrayVariablePhiGradient	_mapped_grad_phi_face_neighbor
const FieldVariablePhiValue *	_phi_face
const FieldVariablePhiGradient *	_grad_phi_face
const FieldVariablePhiSecond *	_second_phi_face
const FieldVariablePhiCurl *	_curl_phi_face
const FieldVariablePhiDivergence *	_div_phi_face
const ADTemplateVariablePhiGradient< OutputShape > *	_ad_grad_phi
const ADTemplateVariablePhiGradient< OutputShape > *	_ad_grad_phi_face
const QBase *	_current_qrule
const FieldVariablePhiValue *	_current_phi
const FieldVariablePhiGradient *	_current_grad_phi
const FieldVariablePhiSecond *	_current_second_phi
const FieldVariablePhiCurl *	_current_curl_phi
const FieldVariablePhiDivergence *	_current_div_phi
const ADTemplateVariablePhiGradient< OutputShape > *	_current_ad_grad_phi
const bool	_use_dual
std::function< const typename OutputTools< OutputType >::VariablePhiValue &(const Assembly &, libMesh::FEType)>	_phi_assembly_method
std::function< const typename OutputTools< OutputShape >::VariablePhiValue &(const Assembly &, libMesh::FEType)>	_phi_face_assembly_method
std::function< const typename OutputTools< OutputShape >::VariablePhiGradient &(const Assembly &, libMesh::FEType)>	_grad_phi_assembly_method
std::function< const typename OutputTools< OutputShape >::VariablePhiGradient &(const Assembly &, libMesh::FEType)>	_grad_phi_face_assembly_method
std::function< const typename OutputTools< OutputShape >::VariablePhiSecond &(const Assembly &, libMesh::FEType)>	_second_phi_assembly_method
std::function< const typename OutputTools< OutputShape >::VariablePhiSecond &(const Assembly &, libMesh::FEType)>	_second_phi_face_assembly_method
std::function< const typename OutputTools< OutputShape >::VariablePhiCurl &(const Assembly &, libMesh::FEType)>	_curl_phi_assembly_method
std::function< const typename OutputTools< OutputShape >::VariablePhiCurl &(const Assembly &, libMesh::FEType)>	_curl_phi_face_assembly_method
std::function< const typename OutputTools< OutputShape >::VariablePhiDivergence &(const Assembly &, libMesh::FEType)>	_div_phi_assembly_method
std::function< const typename OutputTools< OutputShape >::VariablePhiDivergence &(const Assembly &, libMesh::FEType)>	_div_phi_face_assembly_method
std::function< const ADTemplateVariablePhiGradient< OutputShape > &(const Assembly &, libMesh::FEType)>	_ad_grad_phi_assembly_method
std::function< const ADTemplateVariablePhiGradient< OutputShape > &(const Assembly &, libMesh::FEType)>	_ad_grad_phi_face_assembly_method
const TimeIntegrator *	_time_integrator
	Pointer to time integrator. More...
const Node *const &	_node
	The current node. More...
const Elem *const &	_elem
	The current elem. More...
const bool	_displaced
	Whether this variable is being calculated on a displaced system. More...
const unsigned int &	_current_side
	The current element side. More...
ADReal	_ad_real_dummy = 0
	A dummy ADReal variable. More...

Detailed Description

template<typename OutputType>
class MooseVariableData< OutputType >

Definition at line 49 of file MooseVariableData.h.

Member Typedef Documentation

ADDofValue

template<typename OutputType>

typedef Moose::ADType<DofValue>::type MooseVariableDataBase< OutputType >::ADDofValue

inherited

Definition at line 47 of file MooseVariableDataBase.h.

ADDofValues

template<typename OutputType>

typedef MooseArray<ADDofValue> MooseVariableDataBase< OutputType >::ADDofValues

inherited

Definition at line 49 of file MooseVariableDataBase.h.

DofValue

template<typename OutputType>

typedef Moose::DOFType<OutputType>::type MooseVariableDataBase< OutputType >::DofValue

inherited

Definition at line 46 of file MooseVariableDataBase.h.

DofValues

template<typename OutputType>

typedef MooseArray<DofValue> MooseVariableDataBase< OutputType >::DofValues

inherited

Definition at line 48 of file MooseVariableDataBase.h.

FieldVariableCurl

template<typename OutputType >

typedef MooseArray<OutputType> MooseVariableData< OutputType >::FieldVariableCurl

Definition at line 61 of file MooseVariableData.h.

FieldVariableDivergence

template<typename OutputType >

typedef MooseArray<OutputDivergence> MooseVariableData< OutputType >::FieldVariableDivergence

Definition at line 62 of file MooseVariableData.h.

FieldVariableGradient

template<typename OutputType>

typedef MooseArray<OutputGradient> MooseVariableDataBase< OutputType >::FieldVariableGradient

inherited

Definition at line 43 of file MooseVariableDataBase.h.

FieldVariablePhiCurl

template<typename OutputType >

typedef MooseArray<std::vector<OutputShape> > MooseVariableData< OutputType >::FieldVariablePhiCurl

Definition at line 76 of file MooseVariableData.h.

FieldVariablePhiDivergence

template<typename OutputType >

typedef MooseArray<std::vector<OutputShapeDivergence> > MooseVariableData< OutputType >::FieldVariablePhiDivergence

Definition at line 77 of file MooseVariableData.h.

FieldVariablePhiGradient

template<typename OutputType >

typedef MooseArray<std::vector<OutputShapeGradient> > MooseVariableData< OutputType >::FieldVariablePhiGradient

Definition at line 74 of file MooseVariableData.h.

FieldVariablePhiSecond

template<typename OutputType >

typedef MooseArray<std::vector<OutputShapeSecond> > MooseVariableData< OutputType >::FieldVariablePhiSecond

Definition at line 75 of file MooseVariableData.h.

FieldVariablePhiValue

template<typename OutputType >

typedef MooseArray<std::vector<OutputShape> > MooseVariableData< OutputType >::FieldVariablePhiValue

Definition at line 73 of file MooseVariableData.h.

FieldVariableSecond

template<typename OutputType >

typedef MooseArray<OutputSecond> MooseVariableData< OutputType >::FieldVariableSecond

Definition at line 60 of file MooseVariableData.h.

FieldVariableTestCurl

template<typename OutputType >

typedef MooseArray<std::vector<OutputShape> > MooseVariableData< OutputType >::FieldVariableTestCurl

Definition at line 84 of file MooseVariableData.h.

FieldVariableTestDivergence

template<typename OutputType >

typedef MooseArray<std::vector<OutputShapeDivergence> > MooseVariableData< OutputType >::FieldVariableTestDivergence

Definition at line 85 of file MooseVariableData.h.

FieldVariableTestGradient

template<typename OutputType >

typedef MooseArray<std::vector<OutputShapeGradient> > MooseVariableData< OutputType >::FieldVariableTestGradient

Definition at line 82 of file MooseVariableData.h.

FieldVariableTestSecond

template<typename OutputType >

typedef MooseArray<std::vector<OutputShapeSecond> > MooseVariableData< OutputType >::FieldVariableTestSecond

Definition at line 83 of file MooseVariableData.h.

FieldVariableTestValue

template<typename OutputType >

typedef MooseArray<std::vector<OutputShape> > MooseVariableData< OutputType >::FieldVariableTestValue

Definition at line 81 of file MooseVariableData.h.

FieldVariableValue

template<typename OutputType>

typedef MooseArray<OutputType> MooseVariableDataBase< OutputType >::FieldVariableValue

inherited

Definition at line 42 of file MooseVariableDataBase.h.

OutputDivergence

template<typename OutputType>

typedef libMesh::TensorTools::DecrementRank<OutputType>::type MooseVariableDataBase< OutputType >::OutputDivergence

inherited

Definition at line 39 of file MooseVariableDataBase.h.

OutputGradient

template<typename OutputType>

typedef libMesh::TensorTools::IncrementRank<OutputType>::type MooseVariableDataBase< OutputType >::OutputGradient

inherited

Definition at line 37 of file MooseVariableDataBase.h.

OutputSecond

template<typename OutputType>

typedef libMesh::TensorTools::IncrementRank<OutputGradient>::type MooseVariableDataBase< OutputType >::OutputSecond

inherited

Definition at line 38 of file MooseVariableDataBase.h.

OutputShape

template<typename OutputType >

typedef Moose::ShapeType<OutputType>::type MooseVariableData< OutputType >::OutputShape

Definition at line 65 of file MooseVariableData.h.

OutputShapeDivergence

template<typename OutputType >

typedef libMesh::TensorTools::DecrementRank<OutputShape>::type MooseVariableData< OutputType >::OutputShapeDivergence

Definition at line 70 of file MooseVariableData.h.

OutputShapeGradient

template<typename OutputType >

typedef libMesh::TensorTools::IncrementRank<OutputShape>::type MooseVariableData< OutputType >::OutputShapeGradient

Definition at line 68 of file MooseVariableData.h.

OutputShapeSecond

template<typename OutputType >

typedef libMesh::TensorTools::IncrementRank<OutputShapeGradient>::type MooseVariableData< OutputType >::OutputShapeSecond

Definition at line 69 of file MooseVariableData.h.

Constructor & Destructor Documentation

MooseVariableData()

template<typename OutputType >

MooseVariableData< OutputType >::MooseVariableData	(	const MooseVariableFE< OutputType > &	var,
		SystemBase &	sys,
		THREAD_ID	tid,
		Moose::ElementType	element_type,
		const QBase *const &	qrule_in,
		const QBase *const &	qrule_face_in,
		const Node *const &	node,
		const Elem *const &	elem
	)

Definition at line 28 of file MooseVariableData.C.

  : MooseVariableDataBase<OutputType>(var, sys, tid),
    _var(var),
    _fe_type(var.feType()),
    _var_num(var.number()),
    _assembly(_subproblem.assembly(_tid, var.kind() == Moose::VAR_SOLVER ? sys.number() : 0)),
    _element_type(element_type),
    _ad_zero(0),
    _has_dof_indices(false),
    _qrule(qrule_in),
    _qrule_face(qrule_face_in),
    _use_dual(var.useDual()),
    _second_phi_assembly_method(nullptr),
    _second_phi_face_assembly_method(nullptr),
    _curl_phi_assembly_method(nullptr),
    _curl_phi_face_assembly_method(nullptr),
    _div_phi_assembly_method(nullptr),
    _div_phi_face_assembly_method(nullptr),
    _ad_grad_phi_assembly_method(nullptr),
    _ad_grad_phi_face_assembly_method(nullptr),
    _time_integrator(nullptr),
    _node(node),
    _elem(elem),
    _displaced(dynamic_cast<const DisplacedSystem *>(&_sys) ? true : false),
    _current_side(_assembly.side())
{
  _continuity = FEInterface::get_continuity(_fe_type);

  _is_nodal = (_continuity == C_ZERO || _continuity == C_ONE);

  _time_integrator = _sys.queryTimeIntegrator(_var_num);

  // Initialize AD zero with zero derivatives
  const auto old_do = ADReal::do_derivatives;
  ADReal::do_derivatives = true;
  _ad_zero = 0.;
  ADReal::do_derivatives = old_do;

  switch (_element_type)
  {
    case Moose::ElementType::Element:
    {
      _phi_assembly_method = &Assembly::fePhi<OutputShape>;
      _phi_face_assembly_method = &Assembly::fePhiFace<OutputShape>;
      _grad_phi_assembly_method = &Assembly::feGradPhi<OutputShape>;
      _grad_phi_face_assembly_method = &Assembly::feGradPhiFace<OutputShape>;
      _second_phi_assembly_method = &Assembly::feSecondPhi<OutputShape>;
      _second_phi_face_assembly_method = &Assembly::feSecondPhiFace<OutputShape>;
      _curl_phi_assembly_method = &Assembly::feCurlPhi<OutputShape>;
      _curl_phi_face_assembly_method = &Assembly::feCurlPhiFace<OutputShape>;
      _div_phi_assembly_method = &Assembly::feDivPhi<OutputShape>;
      _div_phi_face_assembly_method = &Assembly::feDivPhiFace<OutputShape>;
      _ad_grad_phi_assembly_method = &Assembly::feADGradPhi<OutputShape>;
      _ad_grad_phi_face_assembly_method = &Assembly::feADGradPhiFace<OutputShape>;

      _ad_grad_phi = &_ad_grad_phi_assembly_method(_assembly, _fe_type);
      _ad_grad_phi_face = &_ad_grad_phi_face_assembly_method(_assembly, _fe_type);
      break;
    }
    case Moose::ElementType::Neighbor:
    {
      _phi_assembly_method = &Assembly::fePhiNeighbor<OutputShape>;
      _phi_face_assembly_method = &Assembly::fePhiFaceNeighbor<OutputShape>;
      _grad_phi_assembly_method = &Assembly::feGradPhiNeighbor<OutputShape>;
      _grad_phi_face_assembly_method = &Assembly::feGradPhiFaceNeighbor<OutputShape>;
      _second_phi_assembly_method = &Assembly::feSecondPhiNeighbor<OutputShape>;
      _second_phi_face_assembly_method = &Assembly::feSecondPhiFaceNeighbor<OutputShape>;
      _curl_phi_assembly_method = &Assembly::feCurlPhiNeighbor<OutputShape>;
      _curl_phi_face_assembly_method = &Assembly::feCurlPhiFaceNeighbor<OutputShape>;
      _div_phi_assembly_method = &Assembly::feDivPhiNeighbor<OutputShape>;
      _div_phi_face_assembly_method = &Assembly::feDivPhiFaceNeighbor<OutputShape>;

      _ad_grad_phi = nullptr;
      _ad_grad_phi_face = nullptr;
      break;
    }
    case Moose::ElementType::Lower:
    {
      if (_use_dual)
      {
        _phi_assembly_method = &Assembly::feDualPhiLower<OutputType>;
        _phi_face_assembly_method = &Assembly::feDualPhiLower<OutputType>; // Place holder
        _grad_phi_assembly_method = &Assembly::feGradDualPhiLower<OutputType>;
        _grad_phi_face_assembly_method = &Assembly::feGradDualPhiLower<OutputType>; // Place holder
      }
      else
      {
        _phi_assembly_method = &Assembly::fePhiLower<OutputType>;
        _phi_face_assembly_method = &Assembly::fePhiLower<OutputType>; // Place holder
        _grad_phi_assembly_method = &Assembly::feGradPhiLower<OutputType>;
        _grad_phi_face_assembly_method = &Assembly::feGradPhiLower<OutputType>; // Place holder
      }

      _ad_grad_phi = nullptr;
      _ad_grad_phi_face = nullptr;
      break;
    }
  }
  _phi = &_phi_assembly_method(_assembly, _fe_type);
  _phi_face = &_phi_face_assembly_method(_assembly, _fe_type);
  _grad_phi = &_grad_phi_assembly_method(_assembly, _fe_type);
  _grad_phi_face = &_grad_phi_face_assembly_method(_assembly, _fe_type);
}

Member Function Documentation

adCurlSln()

template<typename OutputType >

const ADTemplateVariableCurl<OutputType>& MooseVariableData< OutputType >::adCurlSln ( ) const

inline

Definition at line 356 of file MooseVariableData.h.

  {
    _need_ad = _need_ad_curl_u = true;
    curlPhi();
    curlPhiFace();
    return _ad_curl_u;
  }

add() [1/2]

template<typename OutputType>

void MooseVariableDataBase< OutputType >::add ( libMesh::NumericVector< libMesh::Number > &  residual )

inherited

Add the current local DOF values to the input vector.

Definition at line 427 of file MooseVariableDataBase.C.

{
  if (_has_dof_values)
  {
    const auto & dof_values = _vector_tags_dof_u[_solution_tag];
    residual.add_vector(&dof_values[0], _dof_indices);
  }
}

add() [2/2]

template<>

void MooseVariableDataBase< RealEigenVector >::add ( NumericVector< Number > &  residual )

inherited

Definition at line 438 of file MooseVariableDataBase.C.

{
  if (_has_dof_values)
  {
    const auto & dof_values = _vector_tags_dof_u[_solution_tag];
    mooseAssert(_dof_indices.size() % _count == 0,
                "Dof indices should be cleanly divisible by the variable count");
    const auto n_shapes = _dof_indices.size() / _count;
    for (const auto indx : index_range(_dof_indices))
    {
      const auto i = indx % n_shapes;
      const auto j = indx / n_shapes;
      residual.add(_dof_indices[indx], dof_values[i](j));
    }
  }
}

adDofValues()

template<typename OutputType >

const MooseVariableData< OutputType >::ADDofValues & MooseVariableData< OutputType >::adDofValues

(

)

const

Return the AD dof values.

Definition at line 772 of file MooseVariableData.h.

{
  _need_ad = true;
  return _ad_dof_values;
}

adDofValuesDot()

template<typename OutputType >

const MooseVariableData< OutputType >::ADDofValues & MooseVariableData< OutputType >::adDofValuesDot

(

)

const

Return the AD time derivative values of degrees of freedom.

Definition at line 780 of file MooseVariableData.h.

{
  _need_ad = _need_ad_u_dot = true;
  if (!_time_integrator)
    // See explanation in adUDot() body
    _need_u_dot = true;
  return _ad_dofs_dot;
}

addSolution()

template<typename OutputType >

void MooseVariableData< OutputType >::addSolution	(	libMesh::NumericVector< libMesh::Number > &	sol,
		const DenseVector< libMesh::Number > &	v
	)		const

Add passed in local DOF values to a solution vector.

Definition at line 1075 of file MooseVariableData.C.

{
  sol.add_vector(v, _dof_indices);
}

adGradPhi()

template<typename OutputType >

const ADTemplateVariablePhiGradient< typename MooseVariableData< OutputType >::OutputShape > & MooseVariableData< OutputType >::adGradPhi

(

)

const

ad_grad_phi getter

Definition at line 831 of file MooseVariableData.h.

{
  if (_element_type == Moose::ElementType::Neighbor || _element_type == Moose::ElementType::Lower)
    mooseError("Unsupported element type: ", Moose::stringify(_element_type));
  mooseAssert(_ad_grad_phi, "this should be non-null");
  return *_ad_grad_phi;
}

adGradPhiFace()

template<typename OutputType >

const ADTemplateVariablePhiGradient< typename MooseVariableData< OutputType >::OutputShape > & MooseVariableData< OutputType >::adGradPhiFace

(

)

const

ad_grad_phi_face getter

Definition at line 841 of file MooseVariableData.h.

{
  if (_element_type == Moose::ElementType::Neighbor || _element_type == Moose::ElementType::Lower)
    mooseError("Unsupported element type: ", Moose::stringify(_element_type));
  mooseAssert(_ad_grad_phi_face, "this should be non-null");
  return *_ad_grad_phi_face;
}

adGradSln()

template<typename OutputType >

const ADTemplateVariableGradient<OutputType>& MooseVariableData< OutputType >::adGradSln ( ) const

inline

Definition at line 304 of file MooseVariableData.h.

  {
    _need_ad = _need_ad_grad_u = true;
    return _ad_grad_u;
  }

adGradSlnDot()

template<typename OutputType >

const ADTemplateVariableGradient<OutputType>& MooseVariableData< OutputType >::adGradSlnDot ( ) const

inline

Definition at line 310 of file MooseVariableData.h.

  {
    _need_ad = _need_ad_grad_u_dot = true;

    if (!_time_integrator)
      // If we don't have a time integrator (this will be the case for variables that are a part of
      // the AuxiliarySystem) then we have no way to calculate _ad_grad_u_dot and we are just going
      // to copy the values from _grad_u_dot. Of course in order to be able to do that we need to
      // calculate _grad_u_dot
      _need_grad_dot = true;

    return _ad_grad_u_dot;
  }

adNodalValue()

template<typename OutputType >

const Moose::ADType< OutputType >::type & MooseVariableData< OutputType >::adNodalValue

(

)

const

Definition at line 791 of file MooseVariableData.h.

{
  _need_ad = true;
  return _ad_nodal_value;
}

adSecondSln()

template<typename OutputType >

const ADTemplateVariableSecond<OutputType>& MooseVariableData< OutputType >::adSecondSln ( ) const

inline

Definition at line 324 of file MooseVariableData.h.

  {
    _need_ad = _need_ad_second_u = true;
    secondPhi();
    secondPhiFace();
    return _ad_second_u;
  }

adSln()

template<typename OutputType >

const ADTemplateVariableValue<OutputType>& MooseVariableData< OutputType >::adSln ( ) const

inline

Definition at line 298 of file MooseVariableData.h.

  {
    _need_ad = _need_ad_u = true;
    return _ad_u;
  }

adUDot()

template<typename OutputType >

const ADTemplateVariableValue< OutputType > & MooseVariableData< OutputType >::adUDot

(

)

const

Definition at line 799 of file MooseVariableData.h.

{
  _need_ad = _need_ad_u_dot = true;

  if (!_time_integrator)
    // If we don't have a time integrator (this will be the case for variables that are a part of
    // the AuxiliarySystem) then we have no way to calculate _ad_u_dot and we are just going to
    // copy the values from _u_dot. Of course in order to be able to do that we need to calculate
    // _u_dot
    _need_u_dot = true;

  return _ad_u_dot;
}

adUDotDot()

template<typename OutputType >

const ADTemplateVariableValue< OutputType > & MooseVariableData< OutputType >::adUDotDot

(

)

const

Definition at line 815 of file MooseVariableData.h.

{
  _need_ad = _need_ad_u_dotdot = true;

  if (!_time_integrator)
    // If we don't have a time integrator (this will be the case for variables that are a part
    // of the AuxiliarySystem) then we have no way to calculate _ad_u_dotdot and we are just
    // going to copy the values from _u_dotdot. Of course in order to be able to do that we need
    // to calculate _u_dotdot
    _need_u_dotdot = true;

  return _ad_u_dotdot;
}

arrayGradPhi()

template<typename OutputType >

const MappedArrayVariablePhiGradient& MooseVariableData< OutputType >::arrayGradPhi ( ) const

inline

mapped_grad_phi getter

Definition at line 156 of file MooseVariableData.h.

  {
    mooseAssert(var().fieldType() == Moose::VarFieldType::VAR_FIELD_ARRAY, "Not an array variable");
    return _mapped_grad_phi;
  }

arrayGradPhiFace()

template<typename OutputType >

const MappedArrayVariablePhiGradient& MooseVariableData< OutputType >::arrayGradPhiFace ( ) const

inline

mapped_grad_phi_face getter

Definition at line 170 of file MooseVariableData.h.

  {
    mooseAssert(var().fieldType() == Moose::VarFieldType::VAR_FIELD_ARRAY, "Not an array variable");
    return _mapped_grad_phi_face;
  }

assignADNodalValue() [1/2]

template<typename OutputType >

void MooseVariableData< OutputType >::assignADNodalValue ( )

private

Helper method for assigning nodal values from their corresponding solution values (dof values as they're referred to here in this class).

This method is only truly meaningful for nodal basis families

Definition at line 1357 of file MooseVariableData.C.

{
  mooseAssert(_ad_dof_values.size(), "The AD dof values container must have size greater than 0");
  _ad_nodal_value = _ad_dof_values[0];
}

assignADNodalValue() [2/2]

template<>

void MooseVariableData< RealVectorValue >::assignADNodalValue ( )

private

Definition at line 1365 of file MooseVariableData.C.

{
  const auto num_dofs = _dof_indices.size();
  mooseAssert(_ad_dof_values.size() == num_dofs,
              "Our dof values container size should match the dof indices container size");
  for (const auto i : make_range(num_dofs))
    _ad_nodal_value(i) = _ad_dof_values[i];
}

assignNodalValue() [1/3]

template<typename OutputType >

void MooseVariableDataBase< OutputType >::assignNodalValue ( )

protectedinherited

Definition at line 723 of file MooseVariableDataBase.C.

{
  bool is_transient = _subproblem.isTransient();
  libmesh_assert(_dof_indices.size());

  auto & dof_values = _vector_tags_dof_u[_solution_tag];
  _nodal_value = dof_values[0];
  _nodal_value_array[0] = _nodal_value;

  if (is_transient)
  {
    if (oldestSolutionStateRequested() >= 1)
    {
      _nodal_value_old = _vector_tags_dof_u[_old_solution_tag][0];
      _nodal_value_old_array[0] = _nodal_value_old;
    }
    if (oldestSolutionStateRequested() >= 2)
    {
      _nodal_value_older = _vector_tags_dof_u[_older_solution_tag][0];
      _nodal_value_older_array[0] = _nodal_value_older;
    }
    if (_need_dof_values_dot)
      _nodal_value_dot = _dof_values_dot[0];
    if (_need_dof_values_dotdot)
      _nodal_value_dotdot = _dof_values_dotdot[0];
    if (_need_dof_values_dot_old)
      _nodal_value_dot_old = _dof_values_dot_old[0];
    if (_need_dof_values_dotdot_old)
      _nodal_value_dotdot_old = _dof_values_dotdot_old[0];
  }
  if (_previous_nl_solution_tag != Moose::INVALID_TAG_ID)
    _nodal_value_previous_nl = _vector_tags_dof_u[_previous_nl_solution_tag][0];
}

assignNodalValue() [2/3]

template<>

void MooseVariableDataBase< RealVectorValue >::assignNodalValue ( )

protectedinherited

assignNodalValue() [3/3]

template<>

void MooseVariableDataBase< RealVectorValue >::assignNodalValue ( )

protectedinherited

Definition at line 759 of file MooseVariableDataBase.C.

{
  bool is_transient = _subproblem.isTransient();

  auto n = _dof_indices.size();
  libmesh_assert(n);

  auto & dof_values = _vector_tags_dof_u[_solution_tag];
  for (decltype(n) i = 0; i < n; ++i)
    _nodal_value(i) = dof_values[i];
  _nodal_value_array[0] = _nodal_value;

  if (is_transient)
  {
    if (oldestSolutionStateRequested() >= 1)
    {
      auto & dof_values_old = _vector_tags_dof_u[_old_solution_tag];
      for (decltype(n) i = 0; i < n; ++i)
        _nodal_value_old(i) = dof_values_old[i];
      _nodal_value_old_array[0] = _nodal_value_old;
    }
    if (oldestSolutionStateRequested() >= 2)
    {
      auto & dof_values_older = _vector_tags_dof_u[_older_solution_tag];
      for (decltype(n) i = 0; i < n; ++i)
        _nodal_value_older(i) = dof_values_older[i];
      _nodal_value_older_array[0] = _nodal_value_older;
    }
    if (_need_dof_values_dot)
      for (decltype(n) i = 0; i < n; ++i)
        _nodal_value_dot(i) = _dof_values_dot[i];
    if (_need_dof_values_dotdot)
      for (decltype(n) i = 0; i < n; ++i)
        _nodal_value_dotdot(i) = _dof_values_dotdot[i];
    if (_need_dof_values_dot_old)
      for (decltype(n) i = 0; i < n; ++i)
        _nodal_value_dot_old(i) = _dof_values_dot_old[i];
    if (_need_dof_values_dotdot_old)
      for (decltype(n) i = 0; i < n; ++i)
        _nodal_value_dotdot_old(i) = _dof_values_dotdot_old[i];
  }
  if (_previous_nl_solution_tag != Moose::INVALID_TAG_ID)
  {
    auto & dof_values_previous_nl = _vector_tags_dof_u[_previous_nl_solution_tag];
    for (decltype(n) i = 0; i < n; ++i)
      _nodal_value_previous_nl(i) = dof_values_previous_nl[i];
  }
}

clearDofIndices()

template<typename OutputType >

void MooseVariableData< OutputType >::clearDofIndices ( )

inline

Definition at line 400 of file MooseVariableData.h.

{ _dof_indices.clear(); }

computeAD()

template<typename OutputType >

template<bool constant_monomial>

void MooseVariableData< OutputType >::computeAD	(	const unsigned int	num_dofs,
		const unsigned int	nqp
	)

compute AD things

Definition at line 790 of file MooseVariableData.C.

{
  fetchADDofValues();
  const auto n_test = num_dofs / _count;

  // Values
  if (_need_ad_u)
    fill<constant_monomial>(_ad_u, *_current_phi, _ad_dof_values, nqp, n_test);
  // Grad
  if (_need_ad_grad_u)
  {
    // The latter check here is for handling the fact that we have not yet implemented
    // calculation of ad_grad_phi for neighbor and neighbor-face, so if we are in that
    // situation we need to default to using the non-ad grad_phi
    if (_displaced && _current_ad_grad_phi)
      fill<constant_monomial>(_ad_grad_u, *_current_ad_grad_phi, _ad_dof_values, nqp, n_test);
    else
      fill<constant_monomial>(_ad_grad_u, *_current_grad_phi, _ad_dof_values, nqp, n_test);
  }
  // Second
  if constexpr (std::is_same_v<OutputType, Real>)
    if (_need_ad_second_u)
      fill<constant_monomial>(_ad_second_u, *_current_second_phi, _ad_dof_values, nqp, n_test);
  // Curl
  if (_need_ad_curl_u)
    fill<constant_monomial>(_ad_curl_u, *_current_curl_phi, _ad_dof_values, nqp, n_test);

  const bool is_transient = _subproblem.isTransient();
  if (is_transient)
  {
    if (_need_ad_u_dot)
    {
      if (_time_integrator)
        fill<constant_monomial>(_ad_u_dot, *_current_phi, _ad_dofs_dot, nqp, n_test);
      // We are too early in the setup to have a time integrator, so we are not really using the
      // AD-derivatives. We set the AD value of the derivatives to the nonAD value
      else
      {
        _ad_u_dot.resize(nqp);
        for (const auto qp : make_range(nqp))
          _ad_u_dot[qp] = _u_dot[qp];
      }
    }

    if (_need_ad_u_dotdot)
    {
      if (_time_integrator)
        fill<constant_monomial>(_ad_u_dotdot, *_current_phi, _ad_dofs_dotdot, nqp, n_test);
      else
      {
        _ad_u_dotdot.resize(nqp);
        for (const auto qp : make_range(nqp))
          _ad_u_dotdot[qp] = _u_dotdot[qp];
      }
    }

    if (_need_ad_grad_u_dot)
    {
      if (_time_integrator)
      {
        // The latter check here is for handling the fact that we have not yet implemented
        // calculation of ad_grad_phi for neighbor and neighbor-face, so if we are in that
        // situation we need to default to using the non-ad grad_phi
        if (_displaced && _current_ad_grad_phi)
          fill<constant_monomial>(_ad_grad_u_dot, *_current_ad_grad_phi, _ad_dofs_dot, nqp, n_test);
        else
          fill<constant_monomial>(_ad_grad_u_dot, *_current_grad_phi, _ad_dofs_dot, nqp, n_test);
      }
      else
      {
        _ad_grad_u_dot.resize(nqp);
        for (const auto qp : make_range(nqp))
          _ad_grad_u_dot[qp] = _grad_u_dot[qp];
      }
    }
  }
}

computeConstantMonomialValues()

template<typename OutputType >

void MooseVariableData< OutputType >::computeConstantMonomialValues

(

)

compute the values for const monomial variables

Definition at line 691 of file MooseVariableData.C.

{
  if (_dof_indices.size() == 0)
    return;

  // Monomial optimizations are not appropriate after p-refinement
  if (_elem->p_level())
    computeValues();
  else
    computeValuesInternal</* constant_monomial = */ true>();
}

computeIncrementAtNode() [1/2]

template<typename OutputType >

void MooseVariableData< OutputType >::computeIncrementAtNode

(

const libMesh::NumericVector< libMesh::Number > &

increment_vec

)

Compute and store incremental change at the current node based on increment_vec.

Definition at line 1209 of file MooseVariableData.C.

{
  if (!isNodal())
    mooseError("computeIncrementAtNode can only be called for nodal variables");

  _increment.resize(1);

  // Compute the increment for the current DOF
  _increment[0] = increment_vec(_dof_indices[0]);
}

computeIncrementAtNode() [2/2]

template<>

void MooseVariableData< RealEigenVector >::computeIncrementAtNode

(

const NumericVector< Number > &

increment_vec

)

Definition at line 1222 of file MooseVariableData.C.

{
  if (!isNodal())
    mooseError("computeIncrementAtNode can only be called for nodal variables");

  _increment.resize(1);

  // Compute the increment for the current DOF
  if (isNodal())
    for (unsigned int j = 0; j < _count; j++)
      _increment[0](j) = increment_vec(_dof_indices[0] + j);
  else
  {
    unsigned int n = 0;
    const auto n_dof_indices = _dof_indices.size();
    for (const auto j : make_range(_count))
    {
      _increment[0](j) = increment_vec(_dof_indices[0] + n);
      n += n_dof_indices;
    }
  }
}

computeIncrementAtQps() [1/2]

template<typename OutputType >

void MooseVariableData< OutputType >::computeIncrementAtQps

(

const libMesh::NumericVector< libMesh::Number > &

increment_vec

)

Compute and store incremental change in solution at QPs based on increment_vec.

Definition at line 1158 of file MooseVariableData.C.

{
  unsigned int nqp = _qrule->n_points();

  _increment.resize(nqp);
  // Compute the increment at each quadrature point
  unsigned int num_dofs = _dof_indices.size();
  for (const auto qp : make_range(nqp))
  {
    _increment[qp] = 0.;
    for (const auto i : make_range(num_dofs))
      _increment[qp] += (*_phi)[i][qp] * increment_vec(_dof_indices[i]);
  }
}

computeIncrementAtQps() [2/2]

template<>

void MooseVariableData< RealEigenVector >::computeIncrementAtQps

(

const NumericVector< Number > &

increment_vec

)

Definition at line 1175 of file MooseVariableData.C.

{
  unsigned int nqp = _qrule->n_points();

  _increment.resize(nqp);
  // Compute the increment at each quadrature point
  unsigned int num_dofs = _dof_indices.size();
  if (isNodal())
  {
    for (const auto qp : make_range(nqp))
    {
      for (const auto i : make_range(num_dofs))
        for (const auto j : make_range(_count))
          _increment[qp](j) += (*_phi)[i][qp] * increment_vec(_dof_indices[i] + j);
    }
  }
  else
  {
    for (const auto qp : make_range(nqp))
    {
      unsigned int n = 0;
      for (const auto j : make_range(_count))
        for (const auto i : make_range(num_dofs))
        {
          _increment[qp](j) += (*_phi)[i][qp] * increment_vec(_dof_indices[i] + n);
          n += num_dofs;
        }
    }
  }
}

computeNodalValues()

template<typename OutputType >

void MooseVariableData< OutputType >::computeNodalValues

(

)

compute nodal things

Definition at line 1338 of file MooseVariableData.C.

{
  if (_has_dof_indices)
  {
    fetchDofValues();
    assignNodalValue();

    if (_need_ad)
    {
      fetchADDofValues();
      assignADNodalValue();
    }
  }
  else
    zeroSizeDofValues();
}

computeValues()

template<typename OutputType >

void MooseVariableData< OutputType >::computeValues

(

)

compute the variable values

Definition at line 684 of file MooseVariableData.C.

{
  computeValuesInternal</* constant_monomial = */ false>();
}

computeValuesInternal()

template<typename OutputType >

template<bool constant_monomial>

void MooseVariableData< OutputType >::computeValuesInternal ( )

private

Internal method for computeValues() and computeConstantMonomialValues()

Monomial is a template parameter so that we get compile time optimization for constant monomial vs non-constant monomial

Definition at line 530 of file MooseVariableData.C.

{
  const auto num_dofs = _dof_indices.size();
  const auto num_shapes = num_dofs / _count;

  if (num_dofs > 0)
    fetchDofValues();

  const bool is_transient = _subproblem.isTransient();
  const auto nqp = _current_qrule->n_points();
  const auto & active_coupleable_matrix_tags =
      _subproblem.getActiveFEVariableCoupleableMatrixTags(_tid);

  // Map grad_phi using Eigen so that we can perform array operations easier
  if constexpr (std::is_same_v<OutputType, RealEigenVector>)
  {
    if (_qrule == _current_qrule)
    {
      _mapped_grad_phi.resize(num_shapes);
      for (const auto i : make_range(num_shapes))
      {
        _mapped_grad_phi[i].resize(nqp, Eigen::Map<RealDIMValue>(nullptr));
        for (const auto qp : make_range(nqp))
          // Note: this does NOT do any allocation.  It is "reconstructing" the object in place
          new (&_mapped_grad_phi[i][qp])
              Eigen::Map<RealDIMValue>(const_cast<Real *>(&(*_current_grad_phi)[i][qp](0)));
      }
    }
    else
    {
      _mapped_grad_phi_face.resize(num_shapes);
      for (const auto i : make_range(num_shapes))
      {
        _mapped_grad_phi_face[i].resize(nqp, Eigen::Map<RealDIMValue>(nullptr));
        for (const auto qp : make_range(nqp))
          // Note: this does NOT do any allocation.  It is "reconstructing" the object in place
          new (&_mapped_grad_phi_face[i][qp])
              Eigen::Map<RealDIMValue>(const_cast<Real *>(&(*_current_grad_phi)[i][qp](0)));
      }
    }
  }

  mooseAssert(
      !(_need_second || _need_second_old || _need_second_older || _need_second_previous_nl) ||
          _current_second_phi,
      "We're requiring a second calculation but have not set a second shape function!");
  mooseAssert(!(_need_curl || _need_curl_old) || _current_curl_phi,
              "We're requiring a curl calculation but have not set a curl shape function!");
  mooseAssert(!(_need_div || _need_div_old) || _current_div_phi,
              "We're requiring a divergence calculation but have not set a div shape function!");

  // Curl
  if (_need_curl)
    fill<constant_monomial>(
        _curl_u, *_current_curl_phi, _vector_tags_dof_u[_solution_tag], nqp, num_shapes);
  if (is_transient && _need_curl_old)
    fill<constant_monomial>(
        _curl_u_old, *_current_curl_phi, _vector_tags_dof_u[_old_solution_tag], nqp, num_shapes);

  // Div
  if (_need_div)
    fill<constant_monomial>(
        _div_u, *_current_div_phi, _vector_tags_dof_u[_solution_tag], nqp, num_shapes);
  if (is_transient && _need_div_old)
    fill<constant_monomial>(
        _div_u_old, *_current_div_phi, _vector_tags_dof_u[_old_solution_tag], nqp, num_shapes);

  // Second
  if (_need_second)
    fill<constant_monomial>(
        _second_u, *_current_second_phi, _vector_tags_dof_u[_solution_tag], nqp, num_shapes);
  if (_need_second_previous_nl)
    fill<constant_monomial>(_second_u_previous_nl,
                            *_current_second_phi,
                            _vector_tags_dof_u[_previous_nl_solution_tag],
                            nqp,
                            num_shapes);

  // Vector tags
  for (auto tag : _required_vector_tags)
  {
    if (_need_vector_tag_u[tag] && _sys.hasVector(tag))
    {
      mooseAssert(_sys.getVector(tag).closed(), "Vector should be closed");
      fill<constant_monomial>(
          _vector_tag_u[tag], *_current_phi, _vector_tags_dof_u[tag], nqp, num_shapes);
    }
    if (_need_vector_tag_grad[tag] && _sys.hasVector(tag))
    {
      mooseAssert(_sys.getVector(tag).closed(), "Vector should be closed");
      fill<constant_monomial>(
          _vector_tag_grad[tag], *_current_grad_phi, _vector_tags_dof_u[tag], nqp, num_shapes);
    }
  }

  // Matrix tags
  for (auto tag : active_coupleable_matrix_tags)
    if (_need_matrix_tag_u[tag])
      fill<constant_monomial>(
          _matrix_tag_u[tag], *_current_phi, _matrix_tags_dof_u[tag], nqp, num_shapes);

  // Derivatives and old values
  if (is_transient)
  {
    if (_need_second_old)
      fill<constant_monomial>(_second_u_old,
                              *_current_second_phi,
                              _vector_tags_dof_u[_old_solution_tag],
                              nqp,
                              num_shapes);
    if (_need_second_older)
      fill<constant_monomial>(_second_u_older,
                              *_current_second_phi,
                              _vector_tags_dof_u[_older_solution_tag],
                              nqp,
                              num_shapes);
    if (_need_u_dot)
      fill<constant_monomial>(_u_dot, *_current_phi, _dof_values_dot, nqp, num_shapes);
    if (_need_u_dotdot)
      fill<constant_monomial>(_u_dotdot, *_current_phi, _dof_values_dotdot, nqp, num_shapes);
    if (_need_u_dot_old)
      fill<constant_monomial>(_u_dot_old, *_current_phi, _dof_values_dot_old, nqp, num_shapes);
    if (_need_u_dotdot_old)
      fill<constant_monomial>(
          _u_dotdot_old, *_current_phi, _dof_values_dotdot_old, nqp, num_shapes);

    if (_need_du_dot_du)
    {
      _du_dot_du.resize(nqp);
      for (const auto i : make_range(num_shapes))
        for (const auto qp : make_range(nqp))
          _du_dot_du[qp] = _dof_du_dot_du[i];
    }
    if (_need_du_dotdot_du)
    {
      _du_dotdot_du.resize(nqp);
      for (const auto i : make_range(num_shapes))
        for (const auto qp : make_range(nqp))
          _du_dotdot_du[qp] = _dof_du_dotdot_du[i];
    }

    if (_need_grad_dot)
      fill<constant_monomial>(_grad_u_dot, *_current_grad_phi, _dof_values_dot, nqp, num_shapes);
    if (_need_grad_dotdot)
      fill<constant_monomial>(
          _grad_u_dotdot, *_current_grad_phi, _dof_values_dotdot, nqp, num_shapes);
  }

  if (_need_ad)
    computeAD<constant_monomial>(num_dofs, nqp);
}

computingCurl()

template<typename OutputType >

bool MooseVariableData< OutputType >::computingCurl ( ) const

inline

Whether or not this variable is computing the curl.

Definition at line 237 of file MooseVariableData.h.

{ return _need_curl || _need_curl_old; }

computingDiv()

template<typename OutputType >

bool MooseVariableData< OutputType >::computingDiv ( ) const

inline

Whether or not this variable is computing the divergence.

Definition at line 242 of file MooseVariableData.h.

{ return _need_div || _need_div_old; }

curlPhi()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariablePhiCurl & MooseVariableData< OutputType >::curlPhi

(

)

const

curl_phi getter

Definition at line 378 of file MooseVariableData.C.

Referenced by MooseVariableData< OutputType >::adCurlSln().

{
  _curl_phi = &_curl_phi_assembly_method(_assembly, _fe_type);
  return *_curl_phi;
}

curlPhiFace()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariablePhiCurl & MooseVariableData< OutputType >::curlPhiFace

(

)

const

curl_phi_face getter

Definition at line 386 of file MooseVariableData.C.

Referenced by MooseVariableData< OutputType >::adCurlSln().

{
  _curl_phi_face = &_curl_phi_face_assembly_method(_assembly, _fe_type);
  return *_curl_phi_face;
}

curlSln()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariableCurl & MooseVariableData< OutputType >::curlSln

(

Moose::SolutionState

state

)

const

Local solution curl getter.

Parameters

state

The state of the simulation: current, old, older

Definition at line 300 of file MooseVariableData.C.

{
  curlPhi();
  curlPhiFace();
  switch (state)
  {
    case Moose::Current:
    {
      _need_curl = true;
      return _curl_u;
    }

    case Moose::Old:
    {
      _need_curl_old = true;
      return _curl_u_old;
    }

    case Moose::Older:
    {
      _need_curl_older = true;
      return _curl_u_older;
    }

    default:
      mooseError("We don't currently support curl from the previous non-linear iteration");
  }
}

currentElem()

template<typename OutputType >

const Elem* const& MooseVariableData< OutputType >::currentElem ( ) const

inline

The current element.

Definition at line 256 of file MooseVariableData.h.

{ return _elem; }

currentSide()

template<typename OutputType >

const unsigned int& MooseVariableData< OutputType >::currentSide ( ) const

inline

The current side.

Definition at line 261 of file MooseVariableData.h.

{ return _current_side; }

divPhi()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariablePhiDivergence & MooseVariableData< OutputType >::divPhi

(

)

const

divergence_phi getter

Definition at line 394 of file MooseVariableData.C.

{
  _div_phi = &_div_phi_assembly_method(_assembly, _fe_type);
  return *_div_phi;
}

divPhiFace()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariablePhiDivergence & MooseVariableData< OutputType >::divPhiFace

(

)

const

divergence_phi_face getter

Definition at line 402 of file MooseVariableData.C.

{
  _div_phi_face = &_div_phi_face_assembly_method(_assembly, _fe_type);
  return *_div_phi_face;
}

divSln()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariableDivergence & MooseVariableData< OutputType >::divSln

(

Moose::SolutionState

state

)

const

Local solution divergence getter.

Parameters

state

The state of the simulation: current, old, older

Definition at line 331 of file MooseVariableData.C.

{
  divPhi();
  divPhiFace();
  switch (state)
  {
    case Moose::Current:
    {
      _need_div = true;
      return _div_u;
    }

    case Moose::Old:
    {
      _need_div_old = true;
      return _div_u_old;
    }

    case Moose::Older:
    {
      _need_div_older = true;
      return _div_u_older;
    }

    default:
      mooseError("We don't currently support divergence from the previous non-linear iteration");
  }
}

dofIndices()

template<typename OutputType >

const std::vector<dof_id_type>& MooseVariableData< OutputType >::dofIndices ( ) const

inline

Definition at line 398 of file MooseVariableData.h.

{ return _dof_indices; }

dofValues()

template<typename OutputType >

const MooseVariableDataBase< OutputType >::DofValues & MooseVariableDataBase< OutputType >::dofValues ( ) const

inherited

Definition at line 338 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Current);
}

dofValuesDot()

template<typename OutputType >

const MooseVariableData< OutputType >::DofValues & MooseVariableData< OutputType >::dofValuesDot

(

)

const

Definition at line 1083 of file MooseVariableData.C.

{
  if (_sys.solutionUDot())
  {
    _need_dof_values_dot = true;
    return _dof_values_dot;
  }
  else
    mooseError("MooseVariableData: Time derivative of solution (`u_dot`) is not stored. Please set "
               "uDotRequested() to true in FEProblemBase before requesting `u_dot`.");
}

dofValuesDotDot()

template<typename OutputType >

const MooseVariableData< OutputType >::DofValues & MooseVariableData< OutputType >::dofValuesDotDot

(

)

const

Definition at line 1097 of file MooseVariableData.C.

{
  if (_sys.solutionUDotDot())
  {
    _need_dof_values_dotdot = true;
    return _dof_values_dotdot;
  }
  else
    mooseError("MooseVariableData: Second time derivative of solution (`u_dotdot`) is not stored. "
               "Please set uDotDotRequested() to true in FEProblemBase before requesting "
               "`u_dotdot`.");
}

dofValuesDotDotOld()

template<typename OutputType >

const MooseVariableData< OutputType >::DofValues & MooseVariableData< OutputType >::dofValuesDotDotOld

(

)

const

Definition at line 1127 of file MooseVariableData.C.

{
  if (_sys.solutionUDotDotOld())
  {
    _need_dof_values_dotdot_old = true;
    return _dof_values_dotdot_old;
  }
  else
    mooseError("MooseVariableData: Old second time derivative of solution (`u_dotdot_old`) is not "
               "stored. Please set uDotDotOldRequested() to true in FEProblemBase before "
               "requesting `u_dotdot_old`.");
}

dofValuesDotOld()

template<typename OutputType >

const MooseVariableData< OutputType >::DofValues & MooseVariableData< OutputType >::dofValuesDotOld

(

)

const

Definition at line 1112 of file MooseVariableData.C.

{
  if (_sys.solutionUDotOld())
  {
    _need_dof_values_dot_old = true;
    return _dof_values_dot_old;
  }
  else
    mooseError("MooseVariableData: Old time derivative of solution (`u_dot_old`) is not stored. "
               "Please set uDotOldRequested() to true in FEProblemBase before requesting "
               "`u_dot_old`.");
}

dofValuesDuDotDotDu()

template<typename OutputType >

const MooseArray< Number > & MooseVariableData< OutputType >::dofValuesDuDotDotDu

(

)

const

Definition at line 1150 of file MooseVariableData.C.

{
  _need_dof_du_dotdot_du = true;
  return _dof_du_dotdot_du;
}

dofValuesDuDotDu()

template<typename OutputType >

const MooseArray< Number > & MooseVariableData< OutputType >::dofValuesDuDotDu

(

)

const

Definition at line 1142 of file MooseVariableData.C.

{
  _need_dof_du_dot_du = true;
  return _dof_du_dot_du;
}

dofValuesOld()

template<typename OutputType >

const MooseVariableDataBase< OutputType >::DofValues & MooseVariableDataBase< OutputType >::dofValuesOld ( ) const

inherited

Definition at line 345 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Old);
}

dofValuesOlder()

template<typename OutputType >

const MooseVariableDataBase< OutputType >::DofValues & MooseVariableDataBase< OutputType >::dofValuesOlder ( ) const

inherited

Definition at line 352 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Older);
}

dofValuesPreviousNL()

template<typename OutputType >

const MooseVariableDataBase< OutputType >::DofValues & MooseVariableDataBase< OutputType >::dofValuesPreviousNL ( ) const

inherited

Definition at line 359 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::PreviousNL);
}

duDotDotDu()

template<typename OutputType >

const VariableValue& MooseVariableData< OutputType >::duDotDotDu ( ) const

inline

Definition at line 350 of file MooseVariableData.h.

  {
    _need_du_dotdot_du = true;
    return _du_dotdot_du;
  }

duDotDu()

template<typename OutputType >

const VariableValue& MooseVariableData< OutputType >::duDotDu ( ) const

inline

Definition at line 344 of file MooseVariableData.h.

  {
    _need_du_dot_du = true;
    return _du_dot_du;
  }

fetchADDofValues() [1/2]

template<typename OutputType >

void MooseVariableData< OutputType >::fetchADDofValues ( )

private

Helper method for assigning the ad_dof* arrays.

Definition at line 705 of file MooseVariableData.C.

{
  const auto num_dofs = _dof_indices.size();

  const bool do_derivatives = Moose::doDerivatives(_subproblem, _sys);

  _ad_dof_values.resize(num_dofs);
  for (const auto i : make_range(num_dofs))
    _ad_dof_values[i] = _vector_tags_dof_u[_solution_tag][i];
  // NOTE!  You have to do this AFTER setting the value!
  if (do_derivatives)
    for (const auto i : make_range(num_dofs))
      Moose::derivInsert(_ad_dof_values[i].derivatives(), _dof_indices[i], 1.);

  const bool is_transient = _subproblem.isTransient();
  if (is_transient && _need_ad_u_dot)
  {
    _ad_dofs_dot.resize(num_dofs);
    if (_need_ad_u_dotdot)
      _ad_dofs_dotdot.resize(num_dofs);

    if (_time_integrator)
    {
      if (_time_integrator->dt())
      {
        for (const auto i : make_range(num_dofs))
          _ad_dofs_dot[i] = _ad_dof_values[i];
        for (const auto i : make_range(num_dofs))
          _time_integrator->computeADTimeDerivatives(_ad_dofs_dot[i],
                                                     _dof_indices[i],
                                                     _need_ad_u_dotdot ? _ad_dofs_dotdot[i]
                                                                       : _ad_real_dummy);
      }
      else
        // Executing something with a time derivative at initial should not put a NaN
        for (const auto i : make_range(num_dofs))
        {
          _ad_dofs_dot[i] = 0.;
          if (_need_ad_u_dotdot)
            _ad_dofs_dotdot[i] = 0;
        }
    }
    // We are too early in the setup to have a time integrator, so we are not really using the
    // AD-derivatives. We set the AD value of the derivatives to the nonAD value
    else
      for (const auto i : make_range(num_dofs))
      {
        _ad_dofs_dot[i] = _dof_values_dot[i];
        if (_need_ad_u_dotdot)
          _ad_dofs_dotdot[i] = _dof_values_dotdot[i];
      }
  }
}

fetchADDofValues() [2/2]

template<>

void MooseVariableData< RealEigenVector >::fetchADDofValues ( )

private

Definition at line 761 of file MooseVariableData.C.

{
  const auto num_dofs = _dof_indices.size();

  const bool do_derivatives = Moose::doDerivatives(_subproblem, _sys);
  const auto n_test = num_dofs / _count;
  mooseAssert(num_dofs == _count * n_test,
              "Our assertions around number of dofs, test functions, and count are incorrect");

  _ad_dof_values.resize(n_test);
  // Test is outer, count is inner
  for (const auto i : make_range(n_test))
  {
    _ad_dof_values[i].resize(_count);
    for (const auto j : make_range(_count))
    {
      auto & dual_number = _ad_dof_values[i](j);
      const auto global_dof_index = _dof_indices[j * n_test + i];
      dual_number = (*_sys.currentSolution())(global_dof_index);
      // NOTE!  You have to do this AFTER setting the value!
      if (do_derivatives)
        Moose::derivInsert(dual_number.derivatives(), global_dof_index, 1.);
    }
  }
}

fetchDofValues() [1/3]

template<typename OutputType >

void MooseVariableDataBase< OutputType >::fetchDofValues ( )

protectedinherited

Helper methods for assigning dof values from their corresponding solution values.

Definition at line 520 of file MooseVariableDataBase.C.

{
  bool is_transient = _subproblem.isTransient();

  auto n = _dof_indices.size();
  libmesh_assert(n);

  if (is_transient)
  {
    if (_need_u_dot || _need_grad_dot || _need_dof_values_dot)
    {
      libmesh_assert(_sys.solutionUDot());
      _dof_values_dot.resize(n);
      _sys.solutionUDot()->get(_dof_indices, &_dof_values_dot[0]);
    }
    if (_need_u_dotdot || _need_grad_dotdot || _need_dof_values_dotdot)
    {
      libmesh_assert(_sys.solutionUDotDot());
      _dof_values_dotdot.resize(n);
      _sys.solutionUDotDot()->get(_dof_indices, &_dof_values_dotdot[0]);
    }
    if (_need_u_dot_old || _need_dof_values_dot_old)
    {
      libmesh_assert(_sys.solutionUDotOld());
      _dof_values_dot_old.resize(n);
      _sys.solutionUDotOld()->get(_dof_indices, &_dof_values_dot_old[0]);
    }
    if (_need_u_dotdot_old || _need_dof_values_dotdot_old)
    {
      libmesh_assert(_sys.solutionUDotDotOld());
      _dof_values_dotdot_old.resize(n);
      _sys.solutionUDotDotOld()->get(_dof_indices, &_dof_values_dotdot_old[0]);
    }
  }

  for (auto tag : _required_vector_tags)
    if (_need_vector_tag_u[tag] || _need_vector_tag_grad[tag] || _need_vector_tag_dof_u[tag])
      if ((_subproblem.vectorTagType(tag) == Moose::VECTOR_TAG_RESIDUAL &&
           _subproblem.safeAccessTaggedVectors()) ||
          _subproblem.vectorTagType(tag) == Moose::VECTOR_TAG_SOLUTION)
      {
        // tag is defined on problem but may not be used by a system
        // the grain tracker requires being able to read from solution vectors that we are also in
        // the process of writing :-/
        // Note: the extra vector tags are also still not closed when a TagVectorAux uses them
        if (_sys.hasVector(tag) /* && _sys.getVector(tag).closed()*/)
        {
          auto & vec = _sys.getVector(tag);
          _vector_tags_dof_u[tag].resize(n);
          vec.get(_dof_indices, &_vector_tags_dof_u[tag][0]);
        }
      }

  if (_subproblem.safeAccessTaggedMatrices())
  {
    auto & active_coupleable_matrix_tags =
        _subproblem.getActiveFEVariableCoupleableMatrixTags(_tid);

    for (auto tag : active_coupleable_matrix_tags)
    {
      _matrix_tags_dof_u[tag].resize(n);
      if (_need_matrix_tag_dof_u[tag] || _need_matrix_tag_u[tag])
        if (_sys.hasMatrix(tag) && _sys.matrixTagActive(tag))
        {
          mooseAssert(_sys.getMatrix(tag).closed(),
                      "Matrix with tag '" + std::to_string(tag) + "' should be closed");
          auto & mat = _sys.getMatrix(tag);
          for (unsigned i = 0; i < n; i++)
            _matrix_tags_dof_u[tag][i] = mat(_dof_indices[i], _dof_indices[i]);
        }
    }
  }

  if (_need_du_dot_du || _need_dof_du_dot_du)
  {
    _dof_du_dot_du.resize(n);
    for (decltype(n) i = 0; i < n; ++i)
      _dof_du_dot_du[i] = _sys.duDotDu(_var.number());
  }
  if (_need_du_dotdot_du || _need_dof_du_dotdot_du)
  {
    _dof_du_dotdot_du.resize(n);
    for (decltype(n) i = 0; i < n; ++i)
      _dof_du_dotdot_du[i] = _sys.duDotDotDu();
  }
}

fetchDofValues() [2/3]

template<>

void MooseVariableDataBase< RealEigenVector >::fetchDofValues ( )

protectedinherited

fetchDofValues() [3/3]

template<>

void MooseVariableDataBase< RealEigenVector >::fetchDofValues ( )

protectedinherited

Definition at line 624 of file MooseVariableDataBase.C.

{
  bool is_transient = _subproblem.isTransient();

  auto n = _dof_indices.size() / _count;
  libmesh_assert(n);

  if (is_transient)
  {
    if (_need_u_dot || _need_grad_dot || _need_dof_values_dot)
    {
      libmesh_assert(_sys.solutionUDot());
      getArrayDofValues(*_sys.solutionUDot(), n, _dof_values_dot);
    }
    if (_need_u_dotdot || _need_grad_dotdot || _need_dof_values_dotdot)
    {
      libmesh_assert(_sys.solutionUDotDot());
      getArrayDofValues(*_sys.solutionUDot(), n, _dof_values_dotdot);
    }
    if (_need_u_dot_old || _need_dof_values_dot_old)
    {
      libmesh_assert(_sys.solutionUDotOld());
      getArrayDofValues(*_sys.solutionUDotOld(), n, _dof_values_dot_old);
    }
    if (_need_u_dotdot_old || _need_dof_values_dotdot_old)
    {
      libmesh_assert(_sys.solutionUDotDotOld());
      getArrayDofValues(*_sys.solutionUDotDotOld(), n, _dof_values_dotdot_old);
    }
  }

  for (auto tag : _required_vector_tags)
    if ((_subproblem.vectorTagType(tag) == Moose::VECTOR_TAG_RESIDUAL &&
         _subproblem.safeAccessTaggedVectors()) ||
        _subproblem.vectorTagType(tag) == Moose::VECTOR_TAG_SOLUTION)
      // tag is defined on problem but may not be used by a system
      if (_sys.hasVector(tag))
      {
        mooseAssert(_sys.getVector(tag).closed(),
                    "Vector with tag '" + std::to_string(tag) + "' should be closed");
        getArrayDofValues(_sys.getVector(tag), n, _vector_tags_dof_u[tag]);
      }

  if (_subproblem.safeAccessTaggedMatrices())
  {
    auto & active_coupleable_matrix_tags =
        _subproblem.getActiveFEVariableCoupleableMatrixTags(_tid);
    for (auto tag : active_coupleable_matrix_tags)
    {
      _matrix_tags_dof_u[tag].resize(n);
      if (_need_matrix_tag_dof_u[tag] || _need_matrix_tag_u[tag])
        if (_sys.hasMatrix(tag) && _sys.matrixTagActive(tag))
        {
          mooseAssert(_sys.getMatrix(tag).closed(),
                      "Matrix with tag '" + std::to_string(tag) + "' should be closed");
          auto & mat = _sys.getMatrix(tag);
          for (unsigned i = 0; i < n; i++)
            for (unsigned j = 0; j < _count; j++)
              _matrix_tags_dof_u[tag][i](j) = mat(_dof_indices[i] + j, _dof_indices[i] + j);
        }
    }
  }

  if (_need_du_dot_du || _need_dof_du_dot_du)
  {
    _dof_du_dot_du.resize(n);
    for (decltype(n) i = 0; i < n; ++i)
      _dof_du_dot_du[i] = _sys.duDotDu(_var.number());
  }
  if (_need_du_dotdot_du || _need_dof_du_dotdot_du)
  {
    _dof_du_dotdot_du.resize(n);
    for (decltype(n) i = 0; i < n; ++i)
      _dof_du_dotdot_du[i] = _sys.duDotDotDu();
  }
}

fill()

template<typename OutputType >

template<bool constant_monomial, typename DestinationType , typename ShapeType , typename DofValuesType >

void MooseVariableData< OutputType >::fill ( DestinationType &  dest, const ShapeType &  phi, const DofValuesType &  dof_values, unsigned int  nqp, std::size_t  num_shapes  )

private

Definition at line 414 of file MooseVariableData.C.

{
  if constexpr (constant_monomial)
    libmesh_ignore(num_shapes);

  // Deduce OutputType
  constexpr bool is_real = std::is_same_v<OutputType, Real>;
  constexpr bool is_real_vector = std::is_same_v<OutputType, RealVectorValue>;
  constexpr bool is_eigen = std::is_same_v<OutputType, RealEigenVector>;
  static_assert(is_real || is_real_vector || is_eigen, "Unsupported type");

  // this is only used in the RealEigenVector case to get this->_count
  if constexpr (!is_eigen)
    libmesh_ignore(this);

  // Deduce type of value within dest MooseArray
  using dest_array_type = typename std::remove_reference_t<decltype(dest)>::value_type;
  constexpr bool is_value =
      std::is_same_v<dest_array_type, OutputType> ||
      std::is_same_v<dest_array_type, typename Moose::ADType<OutputType>::type>;
  constexpr bool is_gradient =
      std::is_same_v<dest_array_type, OutputGradient> ||
      std::is_same_v<dest_array_type, typename Moose::ADType<OutputGradient>::type>;
  constexpr bool is_second =
      std::is_same_v<dest_array_type, OutputSecond> ||
      std::is_same_v<dest_array_type, typename Moose::ADType<OutputSecond>::type>;
  constexpr bool is_divergence =
      std::is_same_v<dest_array_type, OutputDivergence> ||
      std::is_same_v<dest_array_type, typename Moose::ADType<OutputDivergence>::type>;
  static_assert(is_value || is_gradient || is_second || is_divergence,
                "Unsupported destination array type");

  // Sets a value to zero at a quadrature point
  const auto set_zero = [this, &dest](const auto qp)
  {
    if constexpr (!is_eigen)
      libmesh_ignore(this);

    if constexpr (is_real || is_real_vector)
      dest[qp] = 0;
    else if constexpr (is_eigen)
    {
      if constexpr (is_value)
        dest[qp].setZero(this->_count);
      else if constexpr (is_gradient)
        dest[qp].setZero(this->_count, LIBMESH_DIM);
      else if constexpr (is_second)
        dest[qp].setZero(this->_count, LIBMESH_DIM * LIBMESH_DIM);
      else
        static_assert(Moose::always_false<OutputType, dest_array_type>, "Unsupported type");
    }
    else
      static_assert(Moose::always_false<OutputType, dest_array_type>, "Unsupported type");
  };

  // Accumulates a value
  const auto accumulate = [&dest, &phi, &dof_values](const auto i, const auto qp)
  {
    if constexpr (is_real || is_real_vector || (is_eigen && is_value))
    {
      if constexpr (is_value || is_divergence)
        dest[qp] += phi[i][qp] * dof_values[i];
      else if constexpr (is_gradient || is_second)
        dest[qp].add_scaled(phi[i][qp], dof_values[i]);
      else
        static_assert(Moose::always_false<OutputType, dest_array_type>, "Unsupported type");
    }
    else if constexpr (is_eigen)
    {
      if constexpr (is_gradient)
      {
        for (const auto d : make_range(Moose::dim))
          dest[qp].col(d) += phi[i][qp](d) * dof_values[i];
      }
      else if constexpr (is_second)
      {
        for (unsigned int d = 0, d1 = 0; d1 < LIBMESH_DIM; ++d1)
          for (const auto d2 : make_range(Moose::dim))
            dest[qp].col(d++) += phi[i][qp](d1, d2) * dof_values[i];
      }
      else
        static_assert(Moose::always_false<OutputType, dest_array_type>, "Unsupported type");
    }
    else
      static_assert(Moose::always_false<OutputType, dest_array_type>, "Unsupported type");
  };

  dest.resize(nqp);

  // Monomial case, accumulate dest[0] and set dest[>0] to dest[0]
  if constexpr (constant_monomial)
  {
    mooseAssert(num_shapes == 1, "Should have only one shape function for a constant monomial");
    set_zero(0);
    accumulate(0, 0);
    for (unsigned int qp = 1; qp < nqp; ++qp)
      dest[qp] = dest[0];
  }
  // Non constant monomial case
  else
  {
    for (const auto qp : make_range(nqp))
      set_zero(qp);
    for (const auto i : make_range(num_shapes))
      for (const auto qp : make_range(nqp))
        accumulate(i, qp);
  }
}

getArrayDofValues()

template<typename OutputType>

void MooseVariableDataBase< OutputType >::getArrayDofValues ( const libMesh::NumericVector< libMesh::Number > &  sol, unsigned int  n, MooseArray< RealEigenVector > &  dof_values  ) const

protectedinherited

Definition at line 609 of file MooseVariableDataBase.C.

{
  dof_values.resize(nshapes);
  for (const auto i : make_range(nshapes))
  {
    dof_values[i].resize(_count);
    for (const auto j : make_range(_count))
      dof_values[i](j) = sol(_dof_indices[j * nshapes + i]);
  }
}

getContinuity()

template<typename OutputType >

libMesh::FEContinuity MooseVariableData< OutputType >::getContinuity ( ) const

inlineoverridevirtual

Return the variable continuity.

Implements MooseVariableDataBase< OutputType >.

Definition at line 248 of file MooseVariableData.h.

{ return _continuity; };

getDofIndices()

template<typename OutputType >

void MooseVariableData< OutputType >::getDofIndices	(	const Elem *	elem,
		std::vector< dof_id_type > &	dof_indices
	)		const

Definition at line 1064 of file MooseVariableData.C.

{
  if constexpr (std::is_same<OutputType, RealEigenVector>::value)
    _dof_map.array_dof_indices(elem, dof_indices, _var_num);
  else
    _dof_map.dof_indices(elem, dof_indices, _var_num);
}

getElementalValue() [1/2]

template<typename OutputType >

MooseVariableData< OutputType >::DofValue MooseVariableData< OutputType >::getElementalValue	(	const Elem *	elem,
		Moose::SolutionState	state,
		unsigned int	idx = 0
	)		const

Definition at line 996 of file MooseVariableData.C.

{
  static thread_local std::vector<dof_id_type> dof_indices;
  _dof_map.dof_indices(elem, dof_indices, _var_num);

  switch (state)
  {
    case Moose::Current:
      return (*_sys.currentSolution())(dof_indices[idx]);

    case Moose::Old:
      return _sys.solutionOld()(dof_indices[idx]);

    case Moose::Older:
      return _sys.solutionOlder()(dof_indices[idx]);

    default:
      mooseError("PreviousNL not currently supported for getElementalValue");
  }
}

getElementalValue() [2/2]

template<>

RealEigenVector MooseVariableData< RealEigenVector >::getElementalValue	(	const Elem *	elem,
		const Moose::SolutionState	state,
		const unsigned int	idx
	)		const

Definition at line 1021 of file MooseVariableData.C.

{
  mooseDeprecated(
      "getElementalValue has a really bad API name. It is retrieving a value from the solution "
      "vector for a particular dof index. Generally speaking it has absolutely no equivalence to "
      "an 'elemental' value, which most people would consider to be something like an element "
      "average value");

  static thread_local std::vector<dof_id_type> dof_indices;
  _dof_map.array_dof_indices(elem, dof_indices, _var_num);
  mooseAssert(dof_indices.size() % _count == 0,
              "The number of array dof indices should divide cleanly by the variable count");
  const auto num_shapes = dof_indices.size() / _count;

  RealEigenVector v(_count);

  switch (state)
  {
    case Moose::Current:
      for (unsigned int i = 0; i < _count; ++i)
        v(i) = (*_sys.currentSolution())(dof_indices[i * num_shapes + idx]);
      break;

    case Moose::Old:
      for (unsigned int i = 0; i < _count; ++i)
        v(i) = _sys.solutionOld()(dof_indices[i * num_shapes + idx]);
      break;

    case Moose::Older:
      for (unsigned int i = 0; i < _count; ++i)
        v(i) = _sys.solutionOlder()(dof_indices[i * num_shapes + idx]);
      break;

    default:
      mooseError("PreviousNL not currently supported for getElementalValue");
  }
  return v;
}

getNodalValue() [1/2]

template<typename OutputType >

MooseVariableData< OutputType >::DofValue MooseVariableData< OutputType >::getNodalValue	(	const Node &	node,
		Moose::SolutionState	state
	)		const

Definition at line 925 of file MooseVariableData.C.

{
  mooseAssert(_subproblem.mesh().isSemiLocal(const_cast<Node *>(&node)), "Node is not Semilocal");

  // Make sure that the node has DOFs
  /* Note, this is a reproduction of an assert within libMesh::Node::dof_number, this is done to
   * produce a better error (see misc/check_error.node_value_off_block) */
  mooseAssert(node.n_dofs(_sys.number(), _var_num) > 0,
              "Node " << node.id() << " does not contain any dofs for the "
                      << _sys.system().variable_name(_var_num) << " variable");

  dof_id_type dof = node.dof_number(_sys.number(), _var_num, 0);

  switch (state)
  {
    case Moose::Current:
      return (*_sys.currentSolution())(dof);

    case Moose::Old:
      return _sys.solutionOld()(dof);

    case Moose::Older:
      return _sys.solutionOlder()(dof);

    default:
      mooseError("PreviousNL not currently supported for getNodalValue");
  }
}

getNodalValue() [2/2]

template<>

RealEigenVector MooseVariableData< RealEigenVector >::getNodalValue	(	const Node &	node,
		Moose::SolutionState	state
	)		const

Definition at line 956 of file MooseVariableData.C.

{
  mooseAssert(_subproblem.mesh().isSemiLocal(const_cast<Node *>(&node)), "Node is not Semilocal");

  // Make sure that the node has DOFs
  /* Note, this is a reproduction of an assert within libMesh::Node::dof_number, this is done to
   * produce a better error (see misc/check_error.node_value_off_block) */
  mooseAssert(node.n_dofs(_sys.number(), _var_num) > 0,
              "Node " << node.id() << " does not contain any dofs for the "
                      << _sys.system().variable_name(_var_num) << " variable");

  dof_id_type dof = node.dof_number(_sys.number(), _var_num, 0);

  RealEigenVector v(_count);
  switch (state)
  {
    case Moose::Current:
      for (unsigned int i = 0; i < _count; ++i)
        v(i) = (*_sys.currentSolution())(dof++);
      break;

    case Moose::Old:
      for (unsigned int i = 0; i < _count; ++i)
        v(i) = _sys.solutionOld()(dof++);
      break;

    case Moose::Older:
      for (unsigned int i = 0; i < _count; ++i)
        v(i) = _sys.solutionOlder()(dof++);
      break;

    default:
      mooseError("PreviousNL not currently supported for getNodalValue");
  }
  return v;
}

gradPhi()

template<typename OutputType >

const FieldVariablePhiGradient& MooseVariableData< OutputType >::gradPhi ( ) const

inline

grad_phi getter

Definition at line 151 of file MooseVariableData.h.

{ return *_grad_phi; }

gradPhiFace()

template<typename OutputType >

const FieldVariablePhiGradient& MooseVariableData< OutputType >::gradPhiFace ( ) const

inline

grad_phi_face getter

Definition at line 165 of file MooseVariableData.h.

{ return *_grad_phi_face; }

gradSln()

template<typename OutputType >

const MooseVariableDataBase< OutputType >::FieldVariableGradient & MooseVariableDataBase< OutputType >::gradSln ( Moose::SolutionState  state ) const

inherited

Local solution gradient getter.

Parameters

state

The state of the simulation: current, old, older, previous nl

Definition at line 317 of file MooseVariableDataBase.C.

{
  auto functor = [this](TagID tag_id) -> const FieldVariableGradient &
  { return vectorTagGradient(tag_id); };

  return const_cast<MooseVariableDataBase<OutputType> *>(this)
      ->stateToTagHelper<FieldVariableGradient>(state, functor);
}

gradSlnDot()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariableGradient & MooseVariableData< OutputType >::gradSlnDot

(

)

const

Local time derivative of solution gradient getter.

Definition at line 232 of file MooseVariableData.C.

{
  if (_sys.solutionUDot())
  {
    _need_grad_dot = true;
    return _grad_u_dot;
  }
  else
    mooseError("MooseVariableFE: Time derivative of solution (`u_dot`) is not stored. Please set "
               "uDotRequested() to true in FEProblemBase before requesting `u_dot`.");
}

gradSlnDotDot()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariableGradient & MooseVariableData< OutputType >::gradSlnDotDot

(

)

const

Local second time derivative of solution gradient getter.

Definition at line 246 of file MooseVariableData.C.

{
  if (_sys.solutionUDotDot())
  {
    _need_grad_dotdot = true;
    return _grad_u_dotdot;
  }
  else
    mooseError("MooseVariableFE: Second time derivative of solution (`u_dotdot`) is not stored. "
               "Please set uDotDotRequested() to true in FEProblemBase before requesting "
               "`u_dotdot`.");
}

hasDoFsOnNodes()

template<typename OutputType >

bool MooseVariableData< OutputType >::hasDoFsOnNodes ( ) const

inlineoverridevirtual

Whether this data is associated with a variable that has DoFs on nodes.

Implements MooseVariableDataBase< OutputType >.

Definition at line 247 of file MooseVariableData.h.

{ return _continuity != libMesh::DISCONTINUOUS; }

increment()

template<typename OutputType >

const FieldVariableValue& MooseVariableData< OutputType >::increment ( ) const

inline

Increment getter.

Returns

The increment

Definition at line 454 of file MooseVariableData.h.

{ return _increment; }

insert() [1/2]

template<typename OutputType>

void MooseVariableDataBase< OutputType >::insert ( libMesh::NumericVector< libMesh::Number > &  residual )

inherited

Set the current local DOF values to the input vector.

Definition at line 395 of file MooseVariableDataBase.C.

{
  if (_has_dof_values)
  {
    const auto & dof_values = _vector_tags_dof_u[_solution_tag];
    mooseAssert(dof_values.size() == _dof_indices.size(),
                "Degree of freedom values size and degree of freedom indices sizes must match.");
    residual.insert(&dof_values[0], _dof_indices);
  }
}

insert() [2/2]

template<>

void MooseVariableDataBase< RealEigenVector >::insert ( NumericVector< Number > &  residual )

inherited

Definition at line 408 of file MooseVariableDataBase.C.

{
  if (_has_dof_values)
  {
    const auto & dof_values = _vector_tags_dof_u[_solution_tag];
    mooseAssert(_dof_indices.size() % _count == 0,
                "Dof indices should be cleanly divisible by the variable count");
    const auto n_shapes = _dof_indices.size() / _count;
    for (const auto indx : index_range(_dof_indices))
    {
      const auto i = indx % n_shapes;
      const auto j = indx / n_shapes;
      residual.set(_dof_indices[indx], dof_values[i](j));
    }
  }
}

insertNodalValue() [1/2]

template<typename OutputType >

void MooseVariableData< OutputType >::insertNodalValue	(	libMesh::NumericVector< libMesh::Number > &	residual,
		const DofValue &	v
	)

Write a nodal value to the passed-in solution vector.

Definition at line 908 of file MooseVariableData.C.

{
  residual.set(_nodal_dof_index, v);
}

insertNodalValue() [2/2]

template<>

void MooseVariableData< RealEigenVector >::insertNodalValue	(	NumericVector< Number > &	residual,
		const RealEigenVector &	v
	)

Definition at line 916 of file MooseVariableData.C.

{
  for (const auto j : make_range(_count))
    residual.set(_nodal_dof_index + j, v(j));
}

insertSolutionTag()

template<typename OutputType >

void MooseVariableDataBase< OutputType >::insertSolutionTag ( TagID  tag_id )

protectedinherited

insert a solution tag into our tag containers

Definition at line 330 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataBase< OutputType >::MooseVariableDataBase().

{
  _solution_tags.insert(tag_id);
  _required_vector_tags.insert(tag_id);
}

isNodal()

template<typename OutputType >

bool MooseVariableData< OutputType >::isNodal ( ) const

inlineoverridevirtual

Returns

Whether this data is associated with a nodal variable

Implements MooseVariableDataBase< OutputType >.

Definition at line 246 of file MooseVariableData.h.

{ return _is_nodal; }

isNodalDefined()

template<typename OutputType >

bool MooseVariableData< OutputType >::isNodalDefined ( ) const

inline

Definition at line 251 of file MooseVariableData.h.

{ return _has_dof_indices; }

matrixTagValue()

template<typename OutputType >

const MooseVariableDataBase< OutputType >::FieldVariableValue & MooseVariableDataBase< OutputType >::matrixTagValue ( TagID  tag ) const

inherited

Definition at line 224 of file MooseVariableDataBase.C.

{
  if (tag >= _matrix_tag_u.size())
  {
    _need_matrix_tag_u.resize(tag + 1, false);
    const_cast<MooseVariableDataBase<OutputType> *>(this)->_matrix_tag_u.resize(tag + 1);
  }

  _need_matrix_tag_u[tag] = true;

  if (_sys.hasMatrix(tag))
    return _matrix_tag_u[tag];
  else
    mooseError("Tag ", tag, " is not associated with any matrix for variable ", _var.name());
}

needsAD()

template<typename OutputType >

bool MooseVariableData< OutputType >::needsAD ( ) const

inline

Returns whether this data structure needs automatic differentiation calculations.

Definition at line 105 of file MooseVariableData.h.

{ return _need_ad; }

needSolutionState()

template<typename OutputType >

void MooseVariableDataBase< OutputType >::needSolutionState ( unsigned int  state )

protectedinherited

Request that we have at least state number of older solution states/vectors.

Definition at line 249 of file MooseVariableDataBase.C.

{
  if (state > _max_state)
  {
    _sys.needSolutionState(state);
    _max_state = state;
  }
}

nodalDofIndex()

template<typename OutputType >

const dof_id_type& MooseVariableData< OutputType >::nodalDofIndex ( ) const

inline

Definition at line 250 of file MooseVariableData.h.

{ return _nodal_dof_index; }

nodalMatrixTagValue()

template<typename OutputType >

const MooseVariableDataBase< OutputType >::DofValues & MooseVariableDataBase< OutputType >::nodalMatrixTagValue ( TagID  tag ) const

inherited

Definition at line 121 of file MooseVariableDataBase.C.

{
  if (isNodal())
  {
    if (tag >= _matrix_tags_dof_u.size())
    {
      _need_matrix_tag_dof_u.resize(tag + 1, false);
      const_cast<MooseVariableDataBase<OutputType> *>(this)->_matrix_tags_dof_u.resize(tag + 1);
    }

    _need_matrix_tag_dof_u[tag] = true;

    if (_sys.hasMatrix(tag))
      return _matrix_tags_dof_u[tag];
    else
      mooseError(
          "Tag ", tag, " is not associated with any matrix for nodal variable ", _var.name());
  }
  else
    mooseError("Nodal values can be requested only on nodal variables, variable '",
               _var.name(),
               "' is not nodal.");
}

nodalValue()

template<typename OutputType >

const OutputType & MooseVariableDataBase< OutputType >::nodalValue ( Moose::SolutionState  state ) const

inherited

Definition at line 457 of file MooseVariableDataBase.C.

{
  if (isNodal())
  {
    // Request the correct solution states and data members
    vectorTagDofValue(state);
    switch (state)
    {
      case Moose::Current:
        return _nodal_value;

      case Moose::Old:
        return _nodal_value_old;

      case Moose::Older:
        return _nodal_value_older;

      case Moose::PreviousNL:
        return _nodal_value_previous_nl;

      default:
        // We should never get here but gcc requires that we have a default. See
        // htpps://stackoverflow.com/questions/18680378/after-defining-case-for-all-enum-values-compiler-still-says-control-reaches-e
        mooseError("Unknown SolutionState!");
    }
  }
  else
    mooseError("Nodal values can be requested only on nodal variables, variable '",
               _var.name(),
               "' is not nodal.");
}

nodalValueArray()

template<typename OutputType >

const MooseArray< OutputType > & MooseVariableDataBase< OutputType >::nodalValueArray ( Moose::SolutionState  state ) const

inherited

Definition at line 491 of file MooseVariableDataBase.C.

{
  if (isNodal())
  {
    // Request the correct solution states and data members
    vectorTagDofValue(state);
    switch (state)
    {
      case Moose::Current:
        return _nodal_value_array;

      case Moose::Old:
        return _nodal_value_old_array;

      case Moose::Older:
        return _nodal_value_older_array;

      default:
        mooseError("No current support for PreviousNL for nodal value array");
    }
  }
  else
    mooseError("Nodal values can be requested only on nodal variables, variable '",
               _var.name(),
               "' is not nodal.");
}

nodalValueDot()

template<typename OutputType >

const OutputType & MooseVariableData< OutputType >::nodalValueDot

(

)

const

Definition at line 1248 of file MooseVariableData.C.

{
  if (isNodal())
  {
    if (_sys.solutionUDot())
    {
      _need_dof_values_dot = true;
      return _nodal_value_dot;
    }
    else
      mooseError(
          "MooseVariableData: Time derivative of solution (`u_dot`) is not stored. Please set "
          "uDotRequested() to true in FEProblemBase before requesting `u_dot`.");
  }
  else
    mooseError("Nodal values can be requested only on nodal variables, variable '",
               var().name(),
               "' is not nodal.");
}

nodalValueDotDot()

template<typename OutputType >

const OutputType & MooseVariableData< OutputType >::nodalValueDotDot

(

)

const

Definition at line 1270 of file MooseVariableData.C.

{
  if (isNodal())
  {
    if (_sys.solutionUDotDot())
    {
      _need_dof_values_dotdot = true;
      return _nodal_value_dotdot;
    }
    else
      mooseError(
          "MooseVariableData: Second time derivative of solution (`u_dotdot`) is not stored. "
          "Please set uDotDotRequested() to true in FEProblemBase before requesting "
          "`u_dotdot`.");
  }
  else
    mooseError("Nodal values can be requested only on nodal variables, variable '",
               var().name(),
               "' is not nodal.");
}

nodalValueDotDotOld()

template<typename OutputType >

const OutputType & MooseVariableData< OutputType >::nodalValueDotDotOld

(

)

const

Definition at line 1315 of file MooseVariableData.C.

{
  if (isNodal())
  {
    if (_sys.solutionUDotDotOld())
    {
      _need_dof_values_dotdot_old = true;
      return _nodal_value_dotdot_old;
    }
    else
      mooseError(
          "MooseVariableData: Old second time derivative of solution (`u_dotdot_old`) is not "
          "stored. Please set uDotDotOldRequested() to true in FEProblemBase before "
          "requesting `u_dotdot_old`.");
  }
  else
    mooseError("Nodal values can be requested only on nodal variables, variable '",
               var().name(),
               "' is not nodal.");
}

nodalValueDotOld()

template<typename OutputType >

const OutputType & MooseVariableData< OutputType >::nodalValueDotOld

(

)

const

Definition at line 1293 of file MooseVariableData.C.

{
  if (isNodal())
  {
    if (_sys.solutionUDotOld())
    {
      _need_dof_values_dot_old = true;
      return _nodal_value_dot_old;
    }
    else
      mooseError("MooseVariableData: Old time derivative of solution (`u_dot_old`) is not stored. "
                 "Please set uDotOldRequested() to true in FEProblemBase before requesting "
                 "`u_dot_old`.");
  }
  else
    mooseError("Nodal values can be requested only on nodal variables, variable '",
               var().name(),
               "' is not nodal.");
}

nodalValueDuDotDotDu()

template<typename OutputType >

const OutputType& MooseVariableData< OutputType >::nodalValueDuDotDotDu

(

)

const

nodalValueDuDotDu()

template<typename OutputType >

const OutputType& MooseVariableData< OutputType >::nodalValueDuDotDu

(

)

const

nodalVectorTagValue()

template<typename OutputType >

const MooseVariableDataBase< OutputType >::DofValues & MooseVariableDataBase< OutputType >::nodalVectorTagValue ( TagID  tag ) const

inherited

Definition at line 98 of file MooseVariableDataBase.C.

{
  if (isNodal())
  {
    if (tag >= _need_vector_tag_dof_u.size())
      const_cast<MooseVariableDataBase<OutputType> *>(this)->resizeVectorTagData(tag);

    _need_vector_tag_dof_u[tag] = true;

    if (_sys.hasVector(tag))
      return _vector_tags_dof_u[tag];
    else
      mooseError(
          "Tag ", tag, " is not associated with any vector for nodal variable ", _var.name());
  }
  else
    mooseError("Nodal values can be requested only on nodal variables, variable '",
               _var.name(),
               "' is not nodal.");
}

node()

template<typename OutputType >

const Node* const& MooseVariableData< OutputType >::node ( ) const

inline

Definition at line 249 of file MooseVariableData.h.

{ return _node; }

numberOfDofs()

template<typename OutputType >

unsigned int MooseVariableData< OutputType >::numberOfDofs ( ) const

inline

Definition at line 399 of file MooseVariableData.h.

{ return _dof_indices.size(); }

oldestSolutionStateRequested()

template<typename OutputType >

unsigned int MooseVariableDataBase< OutputType >::oldestSolutionStateRequested ( ) const

inherited

The oldest solution state that is requested for this variable (0 = current, 1 = old, 2 = older, etc).

Definition at line 242 of file MooseVariableDataBase.C.

{
  return _max_state;
}

phi()

template<typename OutputType >

const FieldVariablePhiValue& MooseVariableData< OutputType >::phi ( ) const

inline

phi getter

Definition at line 141 of file MooseVariableData.h.

{ return *_phi; }

phiFace()

template<typename OutputType >

const FieldVariablePhiValue& MooseVariableData< OutputType >::phiFace ( ) const

inline

phi_face getter

Definition at line 146 of file MooseVariableData.h.

{ return *_phi_face; }

phiFaceSize()

template<typename OutputType >

std::size_t MooseVariableData< OutputType >::phiFaceSize ( ) const

inline

Return phiFace size.

Definition at line 224 of file MooseVariableData.h.

{ return _phi_face->size(); }

phiSize()

template<typename OutputType >

std::size_t MooseVariableData< OutputType >::phiSize ( ) const

inline

Return phi size.

Definition at line 219 of file MooseVariableData.h.

{ return _phi->size(); }

prepare()

template<typename OutputType >

void MooseVariableData< OutputType >::prepare

(

)

Get the dof indices corresponding to the current element.

Definition at line 1394 of file MooseVariableData.C.

{
  if constexpr (std::is_same<OutputType, RealEigenVector>::value)
    _dof_map.array_dof_indices(_elem, _dof_indices, _var_num);
  else
    _dof_map.dof_indices(_elem, _dof_indices, _var_num);

  _has_dof_values = false;

  // FIXME: remove this when the Richard's module is migrated to use the new NodalCoupleable
  // interface.
  _has_dof_indices = _dof_indices.size();
}

prepareAux()

template<typename OutputType>

void MooseVariableDataBase< OutputType >::prepareAux ( )

inlineinherited

Clear aux state.

Definition at line 142 of file MooseVariableDataBase.h.

{ _has_dof_values = false; }

prepareIC()

template<typename OutputType >

void MooseVariableData< OutputType >::prepareIC

(

)

prepare the initial condition

Definition at line 1376 of file MooseVariableData.C.

{
  if constexpr (std::is_same<RealEigenVector, OutputType>::value)
    _dof_map.array_dof_indices(_elem, _dof_indices, _var_num);
  else
    _dof_map.dof_indices(_elem, _dof_indices, _var_num);

  mooseAssert(_dof_indices.size() % _count == 0,
              "The number of dof indices should divide cleanly by the variable count");
  const auto num_shapes = _dof_indices.size() / _count;
  _vector_tags_dof_u[_solution_tag].resize(num_shapes);

  unsigned int nqp = _qrule->n_points();
  _vector_tag_u[_solution_tag].resize(nqp);
}

reinitAux()

template<typename OutputType >

void MooseVariableData< OutputType >::reinitAux

(

)

Prepare dof indices and solution values for elemental auxiliary variables.

Definition at line 1431 of file MooseVariableData.C.

{
  /* FIXME: this method is only for elemental auxiliary variables, so
   * we may want to rename it */
  if (_elem)
  {
    if constexpr (std::is_same<RealEigenVector, OutputType>::value)
      _dof_map.array_dof_indices(_elem, _dof_indices, _var_num);
    else
      _dof_map.dof_indices(_elem, _dof_indices, _var_num);
    if (_elem->n_dofs(_sys.number(), _var_num) > 0)
    {
      // FIXME: Setting _nodal_dof_index inside of a method that apparently is only for "elemental"
      // aux variables seems absolutely absurd
      _nodal_dof_index = _dof_indices[0];

      fetchDofValues();

      mooseAssert(_dof_indices.size() % _count == 0,
                  "The number of dof indices should be cleanly divisible by the variable count");
      const auto num_shapes = _dof_indices.size() / _count;
      for (auto & dof_u : _vector_tags_dof_u)
        dof_u.resize(num_shapes);

      for (auto & dof_u : _matrix_tags_dof_u)
        dof_u.resize(num_shapes);

      _has_dof_indices = true;
    }
    else
      _has_dof_indices = false;
  }
  else
    _has_dof_indices = false;
}

reinitNode()

template<typename OutputType >

void MooseVariableData< OutputType >::reinitNode

(

)

Prepare degrees of freedom for the current node.

Definition at line 1410 of file MooseVariableData.C.

{
  if constexpr (std::is_same<OutputType, RealEigenVector>::value)
    _dof_map.array_dof_indices(_node, _dof_indices, _var_num);
  else
    _dof_map.dof_indices(_node, _dof_indices, _var_num);

  const auto n_dofs = _dof_indices.size();
  if (n_dofs)
  {
    // For standard variables. _nodal_dof_index is retrieved by nodalDofIndex() which is used in
    // NodalBC for example
    _nodal_dof_index = _dof_indices[0];
    _has_dof_indices = true;
  }
  else
    _has_dof_indices = false;
}

reinitNodes()

template<typename OutputType >

void MooseVariableData< OutputType >::reinitNodes

(

const std::vector< dof_id_type > &

nodes

)

Set _dof_indices to the degrees of freedom existing on the passed-in nodes.

Parameters

nodes

The nodes to grab the degrees of freedom for

Definition at line 1469 of file MooseVariableData.C.

{
  _dof_indices.clear();
  for (const auto & node_id : nodes)
  {
    auto && nd = _subproblem.mesh().getMesh().query_node_ptr(node_id);
    if (nd && (_subproblem.mesh().isSemiLocal(const_cast<Node *>(nd))))
    {
      if (nd->n_dofs(_sys.number(), _var_num) > 0)
      {
        dof_id_type dof = nd->dof_number(_sys.number(), _var_num, 0);
        _dof_indices.push_back(dof);
      }
    }
  }

  if (!_dof_indices.empty())
    _has_dof_indices = true;
  else
    _has_dof_indices = false;
}

resizeVectorTagData()

template<typename OutputType >

void MooseVariableDataBase< OutputType >::resizeVectorTagData ( TagID  tag )

protectedinherited

resize the vector tag need flags and data containers to accomodate this tag index

Definition at line 147 of file MooseVariableDataBase.C.

Referenced by MooseVariableDataBase< OutputType >::nodalVectorTagValue(), MooseVariableDataBase< OutputType >::vectorTagDofValue(), MooseVariableDataBase< OutputType >::vectorTagGradient(), and MooseVariableDataBase< OutputType >::vectorTagValue().

{
  mooseAssert(_need_vector_tag_dof_u.size() == _need_vector_tag_u.size() &&
                  _need_vector_tag_dof_u.size() == _need_vector_tag_grad.size() &&
                  _need_vector_tag_dof_u.size() == _vector_tags_dof_u.size() &&
                  _need_vector_tag_dof_u.size() == _vector_tag_u.size() &&
                  _need_vector_tag_dof_u.size() == _vector_tag_grad.size(),
              "These sizes should be in sync.");

  auto check_capacity = [tag](const auto & vector_to_check)
  {
    if (tag + 1 > vector_to_check.capacity())
      mooseError("New size greater than tag capacity. This will cause reallocation which will "
                 "invalidate any stored references.");
  };
  check_capacity(_need_vector_tag_dof_u);
  check_capacity(_need_vector_tag_u);
  check_capacity(_need_vector_tag_grad);
  check_capacity(_vector_tags_dof_u);
  check_capacity(_vector_tag_u);
  check_capacity(_vector_tag_grad);

  _need_vector_tag_dof_u.resize(tag + 1, false);
  _need_vector_tag_u.resize(tag + 1, false);
  _need_vector_tag_grad.resize(tag + 1, false);
  _vector_tags_dof_u.resize(tag + 1);
  _vector_tag_u.resize(tag + 1);
  _vector_tag_grad.resize(tag + 1);
}

secondPhi()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariablePhiSecond & MooseVariableData< OutputType >::secondPhi

(

)

const

second_phi getter

Definition at line 362 of file MooseVariableData.C.

Referenced by MooseVariableData< OutputType >::adSecondSln().

{
  _second_phi = &_second_phi_assembly_method(_assembly, _fe_type);
  return *_second_phi;
}

secondPhiFace()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariablePhiSecond & MooseVariableData< OutputType >::secondPhiFace

(

)

const

second_phi_face getter

Definition at line 370 of file MooseVariableData.C.

Referenced by MooseVariableData< OutputType >::adSecondSln().

{
  _second_phi_face = &_second_phi_face_assembly_method(_assembly, _fe_type);
  return *_second_phi_face;
}

secondSln()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariableSecond & MooseVariableData< OutputType >::secondSln

(

Moose::SolutionState

state

)

const

Local solution second spatial derivative getter.

Parameters

state

The state of the simulation: current, old, older, previous nl

Definition at line 261 of file MooseVariableData.C.

{
  secondPhi();
  secondPhiFace();
  switch (state)
  {
    case Moose::Current:
    {
      _need_second = true;
      return _second_u;
    }

    case Moose::Old:
    {
      _need_second_old = true;
      return _second_u_old;
    }

    case Moose::Older:
    {
      _need_second_older = true;
      return _second_u_older;
    }

    case Moose::PreviousNL:
    {
      _need_second_previous_nl = true;
      return _second_u_previous_nl;
    }

    default:
      // We should never get here but gcc requires that we have a default. See
      // htpps://stackoverflow.com/questions/18680378/after-defining-case-for-all-enum-values-compiler-still-says-control-reaches-e
      mooseError("Unknown SolutionState!");
  }
}

setActiveTags()

template<typename OutputType >

void MooseVariableDataBase< OutputType >::setActiveTags ( const std::set< TagID > &  vtags )

inherited

Set the active vector tags.

Parameters

vtags

Additional vector tags that this variable will need to query at dof indices for, in addition to our own required solution tags

Definition at line 314 of file MooseVariableDataBase.h.

{
  _required_vector_tags = _solution_tags;
  for (const auto tag : vtags)
    _required_vector_tags.insert(tag);

  if (!_required_vector_tags.empty())
  {
    const auto largest_tag_id = *_required_vector_tags.rbegin();
    if (largest_tag_id >= _need_vector_tag_dof_u.size())
      resizeVectorTagData(largest_tag_id);
  }
}

setDofValue()

template<typename OutputType >

void MooseVariableData< OutputType >::setDofValue	(	const DofValue &	value,
		unsigned int	index
	)

dof value setters

Definition at line 870 of file MooseVariableData.C.

{
  auto & dof_values = _vector_tags_dof_u[_solution_tag];
  dof_values[index] = value;
  _has_dof_values = true;

  auto & u = _vector_tag_u[_solution_tag];
  const auto nqps = u.size();
  const auto ndofs = dof_values.size();
  for (const auto qp : make_range(nqps))
    u[qp] *= 0.;
  for (const auto qp : make_range(nqps))
    for (const auto i : make_range(ndofs))
      u[qp] += (*_phi)[i][qp] * dof_values[i];
}

setDofValues()

template<typename OutputType >

void MooseVariableData< OutputType >::setDofValues

(

const DenseVector< DofValue > &

values

)

Set local DOF values and evaluate the values on quadrature points.

Definition at line 888 of file MooseVariableData.C.

{
  auto & dof_values = _vector_tags_dof_u[_solution_tag];
  for (unsigned int i = 0; i < values.size(); i++)
    dof_values[i] = values(i);

  _has_dof_values = true;

  auto & u = _vector_tag_u[_solution_tag];
  const auto nqps = u.size();
  const auto ndofs = dof_values.size();
  for (const auto qp : make_range(nqps))
    u[qp] *= 0.;
  for (const auto qp : make_range(nqps))
    for (const auto i : make_range(ndofs))
      u[qp] += (*_phi)[i][qp] * dof_values[i];
}

setGeometry()

template<typename OutputType >

void MooseVariableData< OutputType >::setGeometry

(

Moose::GeometryType

gm_type

)

Set the geometry type before calculating variables values.

Parameters

gm_type

The type type of geometry; either Volume or Face

Definition at line 142 of file MooseVariableData.C.

{
  switch (gm_type)
  {
    case Moose::Volume:
    {
      _current_qrule = _qrule;
      _current_phi = _phi;
      _current_grad_phi = _grad_phi;
      _current_second_phi = _second_phi;
      _current_curl_phi = _curl_phi;
      _current_div_phi = _div_phi;
      _current_ad_grad_phi = _ad_grad_phi;
      break;
    }
    case Moose::Face:
    {
      _current_qrule = _qrule_face;
      _current_phi = _phi_face;
      _current_grad_phi = _grad_phi_face;
      _current_second_phi = _second_phi_face;
      _current_curl_phi = _curl_phi_face;
      _current_div_phi = _div_phi_face;
      _current_ad_grad_phi = _ad_grad_phi_face;
      break;
    }
  }
}

setNodalValue() [1/2]

template<typename OutputType >

void MooseVariableDataBase< OutputType >::setNodalValue ( const OutputType &  value, unsigned int  idx = 0  )

inherited

Set nodal value.

Definition at line 366 of file MooseVariableDataBase.C.

{
  auto & dof_values = _vector_tags_dof_u[_solution_tag];
  mooseAssert(idx < dof_values.size(), "idx is out of the bounds of degree of freedom values");
  dof_values[idx] = value; // update variable nodal value
  _has_dof_values = true;
  _nodal_value = value;

  // Update the qp values as well
  auto & u = _vector_tag_u[_solution_tag];
  for (unsigned int qp = 0; qp < u.size(); qp++)
    u[qp] = value;
}

setNodalValue() [2/2]

template<>

void MooseVariableDataBase< RealVectorValue >::setNodalValue ( const RealVectorValue &  value, unsigned int  idx  )

inherited

Definition at line 382 of file MooseVariableDataBase.C.

{
  auto & dof_values = _vector_tags_dof_u[_solution_tag];
  for (decltype(idx) i = 0; i < dof_values.size(); ++i, ++idx)
    dof_values[idx] = value(i);

  _has_dof_values = true;
  _nodal_value = value;
}

sizeMatrixTagData()

template<typename OutputType >

void MooseVariableDataBase< OutputType >::sizeMatrixTagData ( )

inherited

size matrix tag data

Definition at line 85 of file MooseVariableDataBase.C.

{
  auto num_matrix_tags = _subproblem.numMatrixTags();

  _matrix_tags_dof_u.resize(num_matrix_tags);
  _need_matrix_tag_dof_u.resize(num_matrix_tags, false);

  _need_matrix_tag_u.resize(num_matrix_tags, false);
  _matrix_tag_u.resize(num_matrix_tags);
}

sln()

template<typename OutputType >

const MooseVariableDataBase< OutputType >::FieldVariableValue & MooseVariableDataBase< OutputType >::sln ( Moose::SolutionState  state ) const

inherited

Local solution getter.

Parameters

state

The state of the simulation: current, old, older, previous nl

Definition at line 306 of file MooseVariableDataBase.C.

Referenced by MooseVariableDataFV< OutputType >::sln().

{
  auto functor = [this](TagID tag_id) -> const FieldVariableValue &
  { return vectorTagValue(tag_id); };

  return const_cast<MooseVariableDataBase<OutputType> *>(this)
      ->stateToTagHelper<FieldVariableValue>(state, functor);
}

stateToTagHelper()

template<typename OutputType >

template<typename ReturnType , typename Functor >

const ReturnType & MooseVariableDataBase< OutputType >::stateToTagHelper ( Moose::SolutionState  state, Functor  functor  )

protectedinherited

Helper method that converts a SolutionState argument into a corresponding tag ID, potentially requesting necessary additional solution states and assigning tag id data members, and then calls the provided functor with the tag ID.

Definition at line 261 of file MooseVariableDataBase.C.

{
  if (state > 0)
  {
    // We need to request all states that are between current and the requested state
    stateToTagHelper<ReturnType>(Moose::SolutionState(static_cast<int>(state) - 1), functor);
    needSolutionState(cast_int<unsigned int>(state));
  }

  switch (state)
  {
    case Moose::Current:
      return functor(_subproblem.getVectorTagID(Moose::SOLUTION_TAG));

    case Moose::Old:
    {
      _old_solution_tag = _subproblem.getVectorTagID(Moose::OLD_SOLUTION_TAG);
      insertSolutionTag(_old_solution_tag);
      return functor(_old_solution_tag);
    }

    case Moose::Older:
    {
      _older_solution_tag = _subproblem.getVectorTagID(Moose::OLDER_SOLUTION_TAG);
      insertSolutionTag(_older_solution_tag);
      return functor(_older_solution_tag);
    }

    case Moose::PreviousNL:
    {
      _previous_nl_solution_tag = _subproblem.getVectorTagID(Moose::PREVIOUS_NL_SOLUTION_TAG);
      insertSolutionTag(_previous_nl_solution_tag);
      return functor(_previous_nl_solution_tag);
    }

    default:
      // We should never get here but gcc requires that we have a default. See
      // htpps://stackoverflow.com/questions/18680378/after-defining-case-for-all-enum-values-compiler-still-says-control-reaches-e
      mooseError("Unknown SolutionState!");
  }
}

uDot()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariableValue & MooseVariableData< OutputType >::uDot

(

)

const

Definition at line 173 of file MooseVariableData.C.

{
  if (_sys.solutionUDot())
  {
    _need_u_dot = true;
    return _u_dot;
  }
  else
    mooseError("MooseVariableFE: Time derivative of solution (`u_dot`) is not stored. Please set "
               "uDotRequested() to true in FEProblemBase before requesting `u_dot`.");
}

uDotDot()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariableValue & MooseVariableData< OutputType >::uDotDot

(

)

const

Definition at line 187 of file MooseVariableData.C.

{
  if (_sys.solutionUDotDot())
  {
    _need_u_dotdot = true;
    return _u_dotdot;
  }
  else
    mooseError("MooseVariableFE: Second time derivative of solution (`u_dotdot`) is not stored. "
               "Please set uDotDotRequested() to true in FEProblemBase before requesting "
               "`u_dotdot`.");
}

uDotDotOld()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariableValue & MooseVariableData< OutputType >::uDotDotOld

(

)

const

Definition at line 217 of file MooseVariableData.C.

{
  if (_sys.solutionUDotDotOld())
  {
    _need_u_dotdot_old = true;
    return _u_dotdot_old;
  }
  else
    mooseError("MooseVariableFE: Old second time derivative of solution (`u_dotdot_old`) is not "
               "stored. Please set uDotDotOldRequested() to true in FEProblemBase before "
               "requesting `u_dotdot_old`");
}

uDotOld()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariableValue & MooseVariableData< OutputType >::uDotOld

(

)

const

Definition at line 202 of file MooseVariableData.C.

{
  if (_sys.solutionUDotOld())
  {
    _need_u_dot_old = true;
    return _u_dot_old;
  }
  else
    mooseError("MooseVariableFE: Old time derivative of solution (`u_dot_old`) is not stored. "
               "Please set uDotOldRequested() to true in FEProblemBase before requesting "
               "`u_dot_old`.");
}

usesSecondPhi()

template<typename OutputType >

bool MooseVariableData< OutputType >::usesSecondPhi ( ) const

inline

Whether or not this variable is computing any second derivatives.

Definition at line 229 of file MooseVariableData.h.

  {
    return _need_second || _need_second_old || _need_second_older || _need_second_previous_nl;
  }

var()

template<typename OutputType>

virtual const MooseVariableField<OutputType>& MooseVariableDataBase< OutputType >::var ( ) const

inlineprotectedvirtualinherited

Returns

The variable to which the data in this class belongs to

Reimplemented in MooseVariableDataFV< OutputType >, and MooseVariableDataLinearFV< OutputType >.

Definition at line 153 of file MooseVariableDataBase.h.

Referenced by MooseVariableData< OutputType >::arrayGradPhi(), and MooseVariableData< OutputType >::arrayGradPhiFace().

{ return _var; }

vectorTagDofValue() [1/2]

template<typename OutputType >

const MooseVariableDataBase< OutputType >::DofValues & MooseVariableDataBase< OutputType >::vectorTagDofValue ( TagID  tag ) const

inherited

Definition at line 194 of file MooseVariableDataBase.C.

{
  if (tag >= _need_vector_tag_dof_u.size())
    const_cast<MooseVariableDataBase<OutputType> *>(this)->resizeVectorTagData(tag);

  _need_vector_tag_dof_u[tag] = true;

  if (_sys.hasVector(tag))
    return _vector_tags_dof_u[tag];
  else
    mooseError("Tag ", tag, " is not associated with any vector for variable ", _var.name());
}

vectorTagDofValue() [2/2]

template<typename OutputType >

const MooseVariableDataBase< OutputType >::DofValues & MooseVariableDataBase< OutputType >::vectorTagDofValue ( Moose::SolutionState  state ) const

inherited

Definition at line 328 of file MooseVariableDataBase.C.

{
  auto functor = [this](TagID tag_id) -> const DofValues & { return vectorTagDofValue(tag_id); };

  return const_cast<MooseVariableDataBase<OutputType> *>(this)->stateToTagHelper<DofValues>(
      state, functor);
}

vectorTagGradient()

template<typename OutputType >

const MooseVariableDataBase< OutputType >::FieldVariableGradient & MooseVariableDataBase< OutputType >::vectorTagGradient ( TagID  tag ) const

inherited

Definition at line 209 of file MooseVariableDataBase.C.

{
  if (tag >= _need_vector_tag_grad.size())
    const_cast<MooseVariableDataBase<OutputType> *>(this)->resizeVectorTagData(tag);

  _need_vector_tag_grad[tag] = true;

  if (_sys.hasVector(tag))
    return _vector_tag_grad[tag];
  else
    mooseError("Tag ", tag, " is not associated with any vector for variable ", _var.name());
}

vectorTagValue()

template<typename OutputType >

const MooseVariableDataBase< OutputType >::FieldVariableValue & MooseVariableDataBase< OutputType >::vectorTagValue ( TagID  tag ) const

inherited

Definition at line 179 of file MooseVariableDataBase.C.

{
  if (tag >= _need_vector_tag_u.size())
    const_cast<MooseVariableDataBase<OutputType> *>(this)->resizeVectorTagData(tag);

  _need_vector_tag_u[tag] = true;

  if (_sys.hasVector(tag))
    return _vector_tag_u[tag];
  else
    mooseError("Tag ", tag, " is not associated with any vector for variable ", _var.name());
}

zeroSizeDofValues()

template<typename OutputType >

void MooseVariableDataBase< OutputType >::zeroSizeDofValues ( )

protectedinherited

Definition at line 703 of file MooseVariableDataBase.C.

{
  if (_subproblem.isTransient())
  {
    _dof_values_dot.resize(0);
    _dof_values_dotdot.resize(0);
    _dof_values_dot_old.resize(0);
    _dof_values_dotdot_old.resize(0);
    _dof_du_dot_du.resize(0);
    _dof_du_dotdot_du.resize(0);
  }

  for (auto & dof_values : _vector_tags_dof_u)
    dof_values.resize(0);

  _has_dof_values = false;
}

Member Data Documentation

_ad_curl_u

template<typename OutputType >

ADTemplateVariableCurl<OutputType> MooseVariableData< OutputType >::_ad_curl_u

private

Definition at line 589 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::adCurlSln().

_ad_dof_values

template<typename OutputType >

ADDofValues MooseVariableData< OutputType >::_ad_dof_values

private

Definition at line 581 of file MooseVariableData.h.

_ad_dofs_dot

template<typename OutputType >

ADDofValues MooseVariableData< OutputType >::_ad_dofs_dot

private

Definition at line 582 of file MooseVariableData.h.

_ad_dofs_dot_eigen

template<typename OutputType >

MooseArray<ADRealEigenVector> MooseVariableData< OutputType >::_ad_dofs_dot_eigen

private

Definition at line 583 of file MooseVariableData.h.

_ad_dofs_dotdot

template<typename OutputType >

ADDofValues MooseVariableData< OutputType >::_ad_dofs_dotdot

private

Definition at line 584 of file MooseVariableData.h.

_ad_dofs_dotdot_eigen

template<typename OutputType >

MooseArray<ADRealEigenVector> MooseVariableData< OutputType >::_ad_dofs_dotdot_eigen

private

Definition at line 585 of file MooseVariableData.h.

_ad_grad_phi

template<typename OutputType >

const ADTemplateVariablePhiGradient<OutputShape>* MooseVariableData< OutputType >::_ad_grad_phi

private

Definition at line 637 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_ad_grad_phi_assembly_method

template<typename OutputType >

std::function<const ADTemplateVariablePhiGradient<OutputShape> &(const Assembly &, libMesh::FEType)> MooseVariableData< OutputType >::_ad_grad_phi_assembly_method

private

Definition at line 689 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_ad_grad_phi_face

template<typename OutputType >

const ADTemplateVariablePhiGradient<OutputShape>* MooseVariableData< OutputType >::_ad_grad_phi_face

private

Definition at line 638 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_ad_grad_phi_face_assembly_method

template<typename OutputType >

std::function<const ADTemplateVariablePhiGradient<OutputShape> &(const Assembly &, libMesh::FEType)> MooseVariableData< OutputType >::_ad_grad_phi_face_assembly_method

private

Definition at line 692 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_ad_grad_u

template<typename OutputType >

ADTemplateVariableGradient<OutputType> MooseVariableData< OutputType >::_ad_grad_u

private

Definition at line 579 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::adGradSln().

_ad_grad_u_dot

template<typename OutputType >

ADTemplateVariableGradient<OutputType> MooseVariableData< OutputType >::_ad_grad_u_dot

private

Definition at line 588 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::adGradSlnDot().

_ad_nodal_value

template<typename OutputType >

Moose::ADType<OutputType>::type MooseVariableData< OutputType >::_ad_nodal_value

private

AD nodal value.

Definition at line 523 of file MooseVariableData.h.

_ad_real_dummy

template<typename OutputType >

ADReal MooseVariableData< OutputType >::_ad_real_dummy = 0

private

A dummy ADReal variable.

Definition at line 714 of file MooseVariableData.h.

_ad_second_u

template<typename OutputType >

ADTemplateVariableSecond<OutputType> MooseVariableData< OutputType >::_ad_second_u

private

Definition at line 580 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::adSecondSln().

_ad_u

template<typename OutputType >

ADTemplateVariableValue<OutputType> MooseVariableData< OutputType >::_ad_u

private

AD u.

Definition at line 578 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::adSln().

_ad_u_dot

template<typename OutputType >

ADTemplateVariableValue<OutputType> MooseVariableData< OutputType >::_ad_u_dot

private

Definition at line 586 of file MooseVariableData.h.

_ad_u_dotdot

template<typename OutputType >

ADTemplateVariableValue<OutputType> MooseVariableData< OutputType >::_ad_u_dotdot

private

Definition at line 587 of file MooseVariableData.h.

_ad_zero

template<typename OutputType >

ADReal MooseVariableData< OutputType >::_ad_zero

private

A zero AD variable.

Definition at line 526 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_assembly

template<typename OutputType >

const Assembly& MooseVariableData< OutputType >::_assembly

private

Definition at line 505 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_continuity

template<typename OutputType >

libMesh::FEContinuity MooseVariableData< OutputType >::_continuity

private

Continuity type of the variable.

Definition at line 517 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::getContinuity(), MooseVariableData< OutputType >::hasDoFsOnNodes(), and MooseVariableData< OutputType >::MooseVariableData().

_count

template<typename OutputType>

unsigned int MooseVariableDataBase< OutputType >::_count

protectedinherited

Number of components of the associated variable.

Definition at line 202 of file MooseVariableDataBase.h.

_curl_phi

template<typename OutputType >

const FieldVariablePhiCurl* MooseVariableData< OutputType >::_curl_phi

mutableprivate

Definition at line 621 of file MooseVariableData.h.

_curl_phi_assembly_method

template<typename OutputType >

std::function<const typename OutputTools<OutputShape>::VariablePhiCurl &(const Assembly &, libMesh::FEType)> MooseVariableData< OutputType >::_curl_phi_assembly_method

private

Definition at line 674 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_curl_phi_face

template<typename OutputType >

const FieldVariablePhiCurl* MooseVariableData< OutputType >::_curl_phi_face

mutableprivate

Definition at line 634 of file MooseVariableData.h.

_curl_phi_face_assembly_method

template<typename OutputType >

std::function<const typename OutputTools<OutputShape>::VariablePhiCurl &(const Assembly &, libMesh::FEType)> MooseVariableData< OutputType >::_curl_phi_face_assembly_method

private

Definition at line 677 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_curl_u

template<typename OutputType >

FieldVariableCurl MooseVariableData< OutputType >::_curl_u

private

curl_u

Definition at line 568 of file MooseVariableData.h.

_curl_u_old

template<typename OutputType >

FieldVariableCurl MooseVariableData< OutputType >::_curl_u_old

private

Definition at line 569 of file MooseVariableData.h.

_curl_u_older

template<typename OutputType >

FieldVariableCurl MooseVariableData< OutputType >::_curl_u_older

private

Definition at line 570 of file MooseVariableData.h.

_current_ad_grad_phi

template<typename OutputType >

const ADTemplateVariablePhiGradient<OutputShape>* MooseVariableData< OutputType >::_current_ad_grad_phi

private

Definition at line 646 of file MooseVariableData.h.

_current_curl_phi

template<typename OutputType >

const FieldVariablePhiCurl* MooseVariableData< OutputType >::_current_curl_phi

private

Definition at line 644 of file MooseVariableData.h.

_current_div_phi

template<typename OutputType >

const FieldVariablePhiDivergence* MooseVariableData< OutputType >::_current_div_phi

private

Definition at line 645 of file MooseVariableData.h.

_current_grad_phi

template<typename OutputType >

const FieldVariablePhiGradient* MooseVariableData< OutputType >::_current_grad_phi

private

Definition at line 642 of file MooseVariableData.h.

_current_phi

template<typename OutputType >

const FieldVariablePhiValue* MooseVariableData< OutputType >::_current_phi

private

Definition at line 641 of file MooseVariableData.h.

_current_qrule

template<typename OutputType >

const QBase* MooseVariableData< OutputType >::_current_qrule

private

Definition at line 640 of file MooseVariableData.h.

_current_second_phi

template<typename OutputType >

const FieldVariablePhiSecond* MooseVariableData< OutputType >::_current_second_phi

private

Definition at line 643 of file MooseVariableData.h.

_current_side

template<typename OutputType >

const unsigned int& MooseVariableData< OutputType >::_current_side

private

The current element side.

Definition at line 711 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::currentSide().

_displaced

template<typename OutputType >

const bool MooseVariableData< OutputType >::_displaced

private

Whether this variable is being calculated on a displaced system.

Definition at line 708 of file MooseVariableData.h.

_div_phi

template<typename OutputType >

const FieldVariablePhiDivergence* MooseVariableData< OutputType >::_div_phi

mutableprivate

Definition at line 622 of file MooseVariableData.h.

_div_phi_assembly_method

template<typename OutputType >

std::function<const typename OutputTools<OutputShape>::VariablePhiDivergence &(const Assembly &, libMesh::FEType)> MooseVariableData< OutputType >::_div_phi_assembly_method

private

Definition at line 681 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_div_phi_face

template<typename OutputType >

const FieldVariablePhiDivergence* MooseVariableData< OutputType >::_div_phi_face

mutableprivate

Definition at line 635 of file MooseVariableData.h.

_div_phi_face_assembly_method

template<typename OutputType >

std::function<const typename OutputTools<OutputShape>::VariablePhiDivergence &(const Assembly &, libMesh::FEType)> MooseVariableData< OutputType >::_div_phi_face_assembly_method

private

Definition at line 685 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_div_u

template<typename OutputType >

FieldVariableDivergence MooseVariableData< OutputType >::_div_u

private

divergence_u

Definition at line 573 of file MooseVariableData.h.

_div_u_old

template<typename OutputType >

FieldVariableDivergence MooseVariableData< OutputType >::_div_u_old

private

Definition at line 574 of file MooseVariableData.h.

_div_u_older

template<typename OutputType >

FieldVariableDivergence MooseVariableData< OutputType >::_div_u_older

private

Definition at line 575 of file MooseVariableData.h.

_dof_du_dot_du

template<typename OutputType>

MooseArray<libMesh::Number> MooseVariableDataBase< OutputType >::_dof_du_dot_du

protectedinherited

derivatives of the solution value time derivative with respect to the degrees of freedom

Definition at line 281 of file MooseVariableDataBase.h.

_dof_du_dotdot_du

template<typename OutputType>

MooseArray<libMesh::Number> MooseVariableDataBase< OutputType >::_dof_du_dotdot_du

protectedinherited

derivatives of the solution value second time derivative with respect to the degrees of freedom

Definition at line 284 of file MooseVariableDataBase.h.

_dof_indices

template<typename OutputType>

std::vector<dof_id_type> MooseVariableDataBase< OutputType >::_dof_indices

protectedinherited

The dof indices for the current element.

Definition at line 224 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataLinearFV< OutputType >::clearDofIndices(), MooseVariableDataFV< OutputType >::clearDofIndices(), MooseVariableData< OutputType >::clearDofIndices(), MooseVariableData< OutputType >::dofIndices(), and MooseVariableData< OutputType >::numberOfDofs().

_dof_map

template<typename OutputType>

const libMesh::DofMap& MooseVariableDataBase< OutputType >::_dof_map

protectedinherited

The degree of freedom map from libMesh.

Definition at line 199 of file MooseVariableDataBase.h.

_dof_values_dot

template<typename OutputType>

DofValues MooseVariableDataBase< OutputType >::_dof_values_dot

protectedinherited

time derivative of the solution values

Definition at line 273 of file MooseVariableDataBase.h.

_dof_values_dot_old

template<typename OutputType>

DofValues MooseVariableDataBase< OutputType >::_dof_values_dot_old

protectedinherited

the previous time step's solution value time derivative

Definition at line 277 of file MooseVariableDataBase.h.

_dof_values_dotdot

template<typename OutputType>

DofValues MooseVariableDataBase< OutputType >::_dof_values_dotdot

protectedinherited

second time derivative of the solution values

Definition at line 275 of file MooseVariableDataBase.h.

_dof_values_dotdot_old

template<typename OutputType>

DofValues MooseVariableDataBase< OutputType >::_dof_values_dotdot_old

protectedinherited

the previous time step's solution value second time derivative

Definition at line 279 of file MooseVariableDataBase.h.

_du_dot_du

template<typename OutputType >

VariableValue MooseVariableData< OutputType >::_du_dot_du

private

derivative of u_dot wrt u

Definition at line 606 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::duDotDu().

_du_dotdot_du

template<typename OutputType >

VariableValue MooseVariableData< OutputType >::_du_dotdot_du

private

derivative of u_dotdot wrt u

Definition at line 609 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::duDotDotDu().

_elem

template<typename OutputType >

const Elem* const& MooseVariableData< OutputType >::_elem

private

The current elem.

This has to be a reference because the current elem will be constantly changing. If we initialized this to point to one elem, then in the next calculation we would be pointing to the wrong place!

Definition at line 705 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::currentElem().

_element_type

template<typename OutputType >

Moose::ElementType MooseVariableData< OutputType >::_element_type

private

The element type this object is storing data for. This is either Element, Neighbor, or Lower.

Definition at line 508 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_fe_type

template<typename OutputType >

const libMesh::FEType& MooseVariableData< OutputType >::_fe_type

private

Definition at line 501 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_grad_phi

template<typename OutputType >

const FieldVariablePhiGradient* MooseVariableData< OutputType >::_grad_phi

private

Definition at line 619 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::gradPhi(), and MooseVariableData< OutputType >::MooseVariableData().

_grad_phi_assembly_method

template<typename OutputType >

std::function<const typename OutputTools<OutputShape>::VariablePhiGradient &(const Assembly &, libMesh::FEType)> MooseVariableData< OutputType >::_grad_phi_assembly_method

private

Definition at line 660 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_grad_phi_face

template<typename OutputType >

const FieldVariablePhiGradient* MooseVariableData< OutputType >::_grad_phi_face

private

Definition at line 632 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::gradPhiFace(), and MooseVariableData< OutputType >::MooseVariableData().

_grad_phi_face_assembly_method

template<typename OutputType >

std::function<const typename OutputTools<OutputShape>::VariablePhiGradient &(const Assembly &, libMesh::FEType)> MooseVariableData< OutputType >::_grad_phi_face_assembly_method

private

Definition at line 663 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_grad_u_dot

template<typename OutputType >

FieldVariableGradient MooseVariableData< OutputType >::_grad_u_dot

private

grad_u dots

Definition at line 558 of file MooseVariableData.h.

_grad_u_dotdot

template<typename OutputType >

FieldVariableGradient MooseVariableData< OutputType >::_grad_u_dotdot

private

Definition at line 559 of file MooseVariableData.h.

_has_dof_indices

template<typename OutputType >

bool MooseVariableData< OutputType >::_has_dof_indices

private

Definition at line 555 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::isNodalDefined().

_has_dof_values

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_has_dof_values

protectedinherited

Whether we currently have degree of freedom values stored in our local containers (corresponding to the current element)

Definition at line 206 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataBase< OutputType >::prepareAux().

_increment

template<typename OutputType >

FieldVariableValue MooseVariableData< OutputType >::_increment

private

Increment in the variable used in dampers.

Definition at line 520 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::increment().

_is_nodal

template<typename OutputType >

bool MooseVariableData< OutputType >::_is_nodal

private

if variable is nodal

Definition at line 511 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::isNodal(), and MooseVariableData< OutputType >::MooseVariableData().

_mapped_grad_phi

template<typename OutputType >

MappedArrayVariablePhiGradient MooseVariableData< OutputType >::_mapped_grad_phi

private

Definition at line 625 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::arrayGradPhi().

_mapped_grad_phi_face

template<typename OutputType >

MappedArrayVariablePhiGradient MooseVariableData< OutputType >::_mapped_grad_phi_face

private

Definition at line 626 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::arrayGradPhiFace().

_mapped_grad_phi_face_neighbor

template<typename OutputType >

MappedArrayVariablePhiGradient MooseVariableData< OutputType >::_mapped_grad_phi_face_neighbor

private

Definition at line 628 of file MooseVariableData.h.

_mapped_grad_phi_neighbor

template<typename OutputType >

MappedArrayVariablePhiGradient MooseVariableData< OutputType >::_mapped_grad_phi_neighbor

private

Definition at line 627 of file MooseVariableData.h.

_matrix_tag_u

template<typename OutputType>

std::vector<FieldVariableValue> MooseVariableDataBase< OutputType >::_matrix_tag_u

protectedinherited

Definition at line 238 of file MooseVariableDataBase.h.

_matrix_tags_dof_u

template<typename OutputType>

std::vector<DofValues> MooseVariableDataBase< OutputType >::_matrix_tags_dof_u

protectedinherited

Definition at line 232 of file MooseVariableDataBase.h.

_max_state

template<typename OutputType>

unsigned int MooseVariableDataBase< OutputType >::_max_state

protectedinherited

The maximum number of older solution states our variable needs.

Definition at line 209 of file MooseVariableDataBase.h.

_need_ad

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad = false

mutableprivate

AD flags.

Definition at line 545 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::adCurlSln(), MooseVariableData< OutputType >::adGradSln(), MooseVariableData< OutputType >::adGradSlnDot(), MooseVariableData< OutputType >::adSecondSln(), MooseVariableData< OutputType >::adSln(), and MooseVariableData< OutputType >::needsAD().

_need_ad_curl_u

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_curl_u = false

mutableprivate

Definition at line 550 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::adCurlSln().

_need_ad_div_u

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_div_u = false

mutableprivate

Definition at line 551 of file MooseVariableData.h.

_need_ad_grad_u

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_grad_u = false

mutableprivate

Definition at line 547 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::adGradSln().

_need_ad_grad_u_dot

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_grad_u_dot = false

mutableprivate

Definition at line 548 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::adGradSlnDot().

_need_ad_second_u

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_second_u = false

mutableprivate

Definition at line 549 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::adSecondSln().

_need_ad_u

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_u = false

mutableprivate

Definition at line 546 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::adSln().

_need_ad_u_dot

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_u_dot = false

mutableprivate

Definition at line 552 of file MooseVariableData.h.

_need_ad_u_dotdot

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_u_dotdot = false

mutableprivate

Definition at line 553 of file MooseVariableData.h.

_need_curl

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_curl = false

mutableprivate

curl flags

Definition at line 535 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::computingCurl().

_need_curl_old

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_curl_old = false

mutableprivate

Definition at line 536 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::computingCurl().

_need_curl_older

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_curl_older = false

mutableprivate

Definition at line 537 of file MooseVariableData.h.

_need_div

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_div = false

mutableprivate

divergence flags

Definition at line 540 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::computingDiv().

_need_div_old

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_div_old = false

mutableprivate

Definition at line 541 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::computingDiv().

_need_div_older

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_div_older = false

mutableprivate

Definition at line 542 of file MooseVariableData.h.

_need_dof_du_dot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_du_dot_du

mutableprotectedinherited

Definition at line 269 of file MooseVariableDataBase.h.

_need_dof_du_dotdot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_du_dotdot_du

mutableprotectedinherited

Definition at line 270 of file MooseVariableDataBase.h.

_need_dof_values_dot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dot

mutableprotectedinherited

local solution flags

Definition at line 265 of file MooseVariableDataBase.h.

_need_dof_values_dot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dot_old

mutableprotectedinherited

Definition at line 267 of file MooseVariableDataBase.h.

_need_dof_values_dotdot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dotdot

mutableprotectedinherited

Definition at line 266 of file MooseVariableDataBase.h.

_need_dof_values_dotdot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dotdot_old

mutableprotectedinherited

Definition at line 268 of file MooseVariableDataBase.h.

_need_du_dot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_du_dot_du

mutableprotectedinherited

Definition at line 257 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataFV< OutputType >::duDotDu(), and MooseVariableData< OutputType >::duDotDu().

_need_du_dotdot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_du_dotdot_du

mutableprotectedinherited

Definition at line 258 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataFV< OutputType >::duDotDotDu(), and MooseVariableData< OutputType >::duDotDotDu().

_need_grad_dot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_grad_dot

mutableprotectedinherited

gradient dot flags

Definition at line 261 of file MooseVariableDataBase.h.

Referenced by MooseVariableData< OutputType >::adGradSlnDot().

_need_grad_dotdot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_grad_dotdot

mutableprotectedinherited

Definition at line 262 of file MooseVariableDataBase.h.

_need_matrix_tag_dof_u

template<typename OutputType>

std::vector<bool> MooseVariableDataBase< OutputType >::_need_matrix_tag_dof_u

mutableprotectedinherited

Definition at line 227 of file MooseVariableDataBase.h.

_need_matrix_tag_u

template<typename OutputType>

std::vector<bool> MooseVariableDataBase< OutputType >::_need_matrix_tag_u

mutableprotectedinherited

Definition at line 239 of file MooseVariableDataBase.h.

_need_second

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_second = false

mutableprivate

SolutionState second_u flags.

Definition at line 529 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::usesSecondPhi().

_need_second_old

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_second_old = false

mutableprivate

Definition at line 530 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::usesSecondPhi().

_need_second_older

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_second_older = false

mutableprivate

Definition at line 531 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::usesSecondPhi().

_need_second_previous_nl

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_second_previous_nl = false

mutableprivate

Definition at line 532 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::usesSecondPhi().

_need_u_dot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_u_dot

mutableprotectedinherited

u dot flags

Definition at line 253 of file MooseVariableDataBase.h.

_need_u_dot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_u_dot_old

mutableprotectedinherited

Definition at line 255 of file MooseVariableDataBase.h.

_need_u_dotdot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_u_dotdot

mutableprotectedinherited

Definition at line 254 of file MooseVariableDataBase.h.

_need_u_dotdot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_u_dotdot_old

mutableprotectedinherited

Definition at line 256 of file MooseVariableDataBase.h.

_need_vector_tag_dof_u

template<typename OutputType>

std::vector<bool> MooseVariableDataBase< OutputType >::_need_vector_tag_dof_u

mutableprotectedinherited

Definition at line 226 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataBase< OutputType >::MooseVariableDataBase().

_need_vector_tag_grad

template<typename OutputType>

std::vector<bool> MooseVariableDataBase< OutputType >::_need_vector_tag_grad

mutableprotectedinherited

Definition at line 237 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataBase< OutputType >::MooseVariableDataBase().

_need_vector_tag_u

template<typename OutputType>

std::vector<bool> MooseVariableDataBase< OutputType >::_need_vector_tag_u

mutableprotectedinherited

Definition at line 235 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataBase< OutputType >::MooseVariableDataBase().

_nodal_dof_index

template<typename OutputType >

dof_id_type MooseVariableData< OutputType >::_nodal_dof_index

private

The dof index for the current node.

Definition at line 514 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::nodalDofIndex().

_nodal_value

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value

protectedinherited

Nodal values.

Definition at line 242 of file MooseVariableDataBase.h.

_nodal_value_array

template<typename OutputType>

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_array

protectedinherited

Nodal values as MooseArrays for use with AuxKernels.

Definition at line 248 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataBase< OutputType >::MooseVariableDataBase().

_nodal_value_dot

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_dot

protectedinherited

nodal values of u_dot

Definition at line 287 of file MooseVariableDataBase.h.

_nodal_value_dot_old

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_dot_old

protectedinherited

nodal values of u_dot_old

Definition at line 291 of file MooseVariableDataBase.h.

_nodal_value_dotdot

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_dotdot

protectedinherited

nodal values of u_dotdot

Definition at line 289 of file MooseVariableDataBase.h.

_nodal_value_dotdot_old

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_dotdot_old

protectedinherited

nodal values of u_dotdot_old

Definition at line 293 of file MooseVariableDataBase.h.

_nodal_value_old

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_old

protectedinherited

Definition at line 243 of file MooseVariableDataBase.h.

_nodal_value_old_array

template<typename OutputType>

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_old_array

protectedinherited

Definition at line 249 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataBase< OutputType >::MooseVariableDataBase().

_nodal_value_older

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_older

protectedinherited

Definition at line 244 of file MooseVariableDataBase.h.

_nodal_value_older_array

template<typename OutputType>

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_older_array

protectedinherited

Definition at line 250 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataBase< OutputType >::MooseVariableDataBase().

_nodal_value_previous_nl

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_previous_nl

protectedinherited

Definition at line 245 of file MooseVariableDataBase.h.

_node

template<typename OutputType >

const Node* const& MooseVariableData< OutputType >::_node

private

The current node.

This has to be a reference because the current node will be constantly changing. If we initialized this to point to one node, then in the next calculation we would be pointing to the wrong place!

Definition at line 700 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::node().

_old_solution_tag

template<typename OutputType>

TagID MooseVariableDataBase< OutputType >::_old_solution_tag

protectedinherited

The vector tag ID corresponding to the old solution vector.

Definition at line 215 of file MooseVariableDataBase.h.

_older_solution_tag

template<typename OutputType>

TagID MooseVariableDataBase< OutputType >::_older_solution_tag

protectedinherited

The vector tag ID corresponding to the older solution vector.

Definition at line 218 of file MooseVariableDataBase.h.

_phi

template<typename OutputType >

const FieldVariablePhiValue* MooseVariableData< OutputType >::_phi

private

Definition at line 618 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData(), MooseVariableData< OutputType >::phi(), and MooseVariableData< OutputType >::phiSize().

_phi_assembly_method

template<typename OutputType >

std::function<const typename OutputTools<OutputType>::VariablePhiValue &(const Assembly &, libMesh::FEType)> MooseVariableData< OutputType >::_phi_assembly_method

private

Definition at line 653 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_phi_face

template<typename OutputType >

const FieldVariablePhiValue* MooseVariableData< OutputType >::_phi_face

private

Definition at line 631 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData(), MooseVariableData< OutputType >::phiFace(), and MooseVariableData< OutputType >::phiFaceSize().

_phi_face_assembly_method

template<typename OutputType >

std::function<const typename OutputTools<OutputShape>::VariablePhiValue &(const Assembly &, libMesh::FEType)> MooseVariableData< OutputType >::_phi_face_assembly_method

private

Definition at line 656 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_previous_nl_solution_tag

template<typename OutputType>

TagID MooseVariableDataBase< OutputType >::_previous_nl_solution_tag

protectedinherited

The vector tag ID corresponding to the previous nonlinear iteration's solution vector.

Definition at line 221 of file MooseVariableDataBase.h.

_qrule

template<typename OutputType >

const QBase* const& MooseVariableData< OutputType >::_qrule

private

The current qrule.

This has to be a reference because the current qrule will be constantly changing. If we initialized this to point to one qrule, then in the next calculation we would be pointing to the wrong place!

Definition at line 614 of file MooseVariableData.h.

_qrule_face

template<typename OutputType >

const QBase* const& MooseVariableData< OutputType >::_qrule_face

private

Definition at line 615 of file MooseVariableData.h.

_required_vector_tags

template<typename OutputType>

std::set<TagID> MooseVariableDataBase< OutputType >::_required_vector_tags

protectedinherited

The set of vector tags (residual + solution) we need to evaluate.

Definition at line 296 of file MooseVariableDataBase.h.

_second_phi

template<typename OutputType >

const FieldVariablePhiSecond* MooseVariableData< OutputType >::_second_phi

mutableprivate

Definition at line 620 of file MooseVariableData.h.

_second_phi_assembly_method

template<typename OutputType >

std::function<const typename OutputTools<OutputShape>::VariablePhiSecond &(const Assembly &, libMesh::FEType)> MooseVariableData< OutputType >::_second_phi_assembly_method

private

Definition at line 667 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_second_phi_face

template<typename OutputType >

const FieldVariablePhiSecond* MooseVariableData< OutputType >::_second_phi_face

mutableprivate

Definition at line 633 of file MooseVariableData.h.

_second_phi_face_assembly_method

template<typename OutputType >

std::function<const typename OutputTools<OutputShape>::VariablePhiSecond &(const Assembly &, libMesh::FEType)> MooseVariableData< OutputType >::_second_phi_face_assembly_method

private

Definition at line 670 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_second_u

template<typename OutputType >

FieldVariableSecond MooseVariableData< OutputType >::_second_u

private

second_u

Definition at line 562 of file MooseVariableData.h.

_second_u_old

template<typename OutputType >

FieldVariableSecond MooseVariableData< OutputType >::_second_u_old

private

Definition at line 563 of file MooseVariableData.h.

_second_u_older

template<typename OutputType >

FieldVariableSecond MooseVariableData< OutputType >::_second_u_older

private

Definition at line 564 of file MooseVariableData.h.

_second_u_previous_nl

template<typename OutputType >

FieldVariableSecond MooseVariableData< OutputType >::_second_u_previous_nl

private

Definition at line 565 of file MooseVariableData.h.

_solution_tag

template<typename OutputType>

TagID MooseVariableDataBase< OutputType >::_solution_tag

protectedinherited

The vector tag ID corresponding to the solution vector.

Definition at line 212 of file MooseVariableDataBase.h.

_solution_tags

template<typename OutputType>

std::set<TagID> MooseVariableDataBase< OutputType >::_solution_tags

protectedinherited

The set of solution tags we need to evaluate.

Definition at line 299 of file MooseVariableDataBase.h.

_subproblem

template<typename OutputType>

const SubProblem& MooseVariableDataBase< OutputType >::_subproblem

protectedinherited

The subproblem which we can query for information related to tagged vectors and matrices.

Definition at line 193 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataBase< OutputType >::MooseVariableDataBase(), and MooseVariableDataFV< OutputType >::MooseVariableDataFV().

_sys

template<typename OutputType>

SystemBase& MooseVariableDataBase< OutputType >::_sys

protectedinherited

The MOOSE system which ultimately holds the vectors and matrices relevant to this variable data.

Definition at line 190 of file MooseVariableDataBase.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_tid

template<typename OutputType>

const THREAD_ID MooseVariableDataBase< OutputType >::_tid

protectedinherited

The thread ID that this object is on.

Definition at line 196 of file MooseVariableDataBase.h.

_time_integrator

template<typename OutputType >

const TimeIntegrator* MooseVariableData< OutputType >::_time_integrator

private

Pointer to time integrator.

Definition at line 695 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::adGradSlnDot(), and MooseVariableData< OutputType >::MooseVariableData().

_u_dot

template<typename OutputType >

FieldVariableValue MooseVariableData< OutputType >::_u_dot

private

u_dot (time derivative)

Definition at line 594 of file MooseVariableData.h.

_u_dot_old

template<typename OutputType >

FieldVariableValue MooseVariableData< OutputType >::_u_dot_old

private

u_dot_old (time derivative)

Definition at line 600 of file MooseVariableData.h.

_u_dotdot

template<typename OutputType >

FieldVariableValue MooseVariableData< OutputType >::_u_dotdot

private

u_dotdot (second time derivative)

Definition at line 597 of file MooseVariableData.h.

_u_dotdot_old

template<typename OutputType >

FieldVariableValue MooseVariableData< OutputType >::_u_dotdot_old

private

u_dotdot_old (second time derivative)

Definition at line 603 of file MooseVariableData.h.

_use_dual

template<typename OutputType >

const bool MooseVariableData< OutputType >::_use_dual

private

Definition at line 649 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_var

template<typename OutputType >

const MooseVariableFE<OutputType>& MooseVariableData< OutputType >::_var

private

A const reference to the owning MooseVariableFE object.

Definition at line 499 of file MooseVariableData.h.

_var_num

template<typename OutputType >

const unsigned int MooseVariableData< OutputType >::_var_num

private

Definition at line 503 of file MooseVariableData.h.

Referenced by MooseVariableData< OutputType >::MooseVariableData().

_vector_tag_grad

template<typename OutputType>

std::vector<FieldVariableGradient> MooseVariableDataBase< OutputType >::_vector_tag_grad

protectedinherited

Definition at line 236 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataBase< OutputType >::MooseVariableDataBase().

_vector_tag_u

template<typename OutputType>

std::vector<FieldVariableValue> MooseVariableDataBase< OutputType >::_vector_tag_u

protectedinherited

Definition at line 234 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataBase< OutputType >::MooseVariableDataBase().

_vector_tags_dof_u

template<typename OutputType>

std::vector<DofValues> MooseVariableDataBase< OutputType >::_vector_tags_dof_u

protectedinherited

Definition at line 230 of file MooseVariableDataBase.h.

Referenced by MooseVariableDataBase< OutputType >::MooseVariableDataBase().

---

The documentation for this class was generated from the following files:

• include/variables/MooseVariableData.h
• src/variables/MooseVariableData.C