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

void	setGeometry (Moose::GeometryType gm_type)
	Set the geometry type before calculating variables values.

void	computeValues ()
	compute the variable values

void	computeConstantMonomialValues ()
	compute the values for const monomial variables

template<bool constant_monomial>
void	computeAD (const unsigned int num_dofs, const unsigned int nqp)
	compute AD things

void	computeNodalValues ()
	compute nodal things

const FieldVariablePhiValue &	phi () const
	phi getter

const FieldVariablePhiValue &	phiFace () const
	phi_face getter

const FieldVariablePhiGradient &	gradPhi () const
	grad_phi getter

const MappedArrayVariablePhiGradient &	arrayGradPhi () const
	mapped_grad_phi getter

const FieldVariablePhiGradient &	gradPhiFace () const
	grad_phi_face getter

const MappedArrayVariablePhiGradient &	arrayGradPhiFace () const
	mapped_grad_phi_face getter

const FieldVariablePhiSecond &	secondPhi () const
	second_phi getter

const FieldVariablePhiSecond &	secondPhiFace () const
	second_phi_face getter

const FieldVariablePhiCurl &	curlPhi () const
	curl_phi getter

const FieldVariablePhiCurl &	curlPhiFace () const
	curl_phi_face getter

const FieldVariablePhiDivergence &	divPhi () const
	divergence_phi getter

const FieldVariablePhiDivergence &	divPhiFace () const
	divergence_phi_face getter

const ADTemplateVariablePhiGradient< OutputShape > &	adGradPhi () const
	ad_grad_phi getter

const ADTemplateVariablePhiGradient< OutputShape > &	adGradPhiFace () const
	ad_grad_phi_face getter

std::size_t	phiSize () const
	Return phi size.

std::size_t	phiFaceSize () const
	Return phiFace size.

bool	usesSecondPhi () const
	Whether or not this variable is computing any second derivatives.

bool	computingCurl () const
	Whether or not this variable is computing the curl.

bool	computingDiv () const
	Whether or not this variable is computing the divergence.

bool	isNodal () const override

bool	hasDoFsOnNodes () const override
	Whether this data is associated with a variable that has DoFs on nodes.

libMesh::FEContinuity	getContinuity () const override
	Return the variable continuity.

const Node *const &	node () const

const dof_id_type &	nodalDofIndex () const

bool	isNodalDefined () const

const Elem *const &	currentElem () const
	The current element.

const unsigned int &	currentSide () const
	The current side.

void	prepareIC ()
	prepare the initial condition

const FieldVariableGradient &	gradSlnDot () const
	Local time derivative of solution gradient getter.

const FieldVariableGradient &	gradSlnDotDot () const
	Local second time derivative of solution gradient getter.

const FieldVariableSecond &	secondSln (Moose::SolutionState state) const
	Local solution second spatial derivative getter.

const FieldVariableCurl &	curlSln (Moose::SolutionState state) const
	Local solution curl getter.

const FieldVariableDivergence &	divSln (Moose::SolutionState state) const
	Local solution divergence getter.

const ADTemplateVariableValue< OutputType > &	adSln () const

const ADTemplateVariableGradient< OutputType > &	adGradSln () const

const ADTemplateVariableValue< OutputType > &	adSlnFace () const
	Solution getter for objects that only ever evaluate on element faces, such as AD integrated BCs.

const ADTemplateVariableGradient< OutputType > &	adGradSlnFace () const
	Face counterpart of adGradSln(); see adSlnFace().

const ADTemplateVariableGradient< OutputType > &	adGradSlnDot () const
	Volume-only: on element faces the AD gradient time derivative is not computed, because it would require the AD face shape function gradients, and the returned array is left empty.

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.

void	insertNodalValue (libMesh::NumericVector< libMesh::Number > &residual, const DofValue &v)
	Write a nodal value to the passed-in solution vector.

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.

void	reinitNode ()
	Prepare degrees of freedom for the current node.

void	reinitAux ()
	Prepare dof indices and solution values for elemental auxiliary variables.

void	reinitNodes (const std::vector< dof_id_type > &nodes)
	Set _dof_indices to the degrees of freedom existing on the passed-in nodes.

void	addSolution (libMesh::NumericVector< libMesh::Number > &sol, const DenseVector< libMesh::Number > &v) const
	Add passed in local DOF values to a solution vector.

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.

const ADDofValues &	adDofValuesDot () const
	Return the AD time derivative values of degrees of freedom.

const FieldVariableValue &	increment () const
	Increment getter.

void	computeIncrementAtQps (const libMesh::NumericVector< libMesh::Number > &increment_vec)
	Compute and store incremental change in solution at QPs based on increment_vec.

void	computeIncrementAtNode (const libMesh::NumericVector< libMesh::Number > &increment_vec)
	Compute and store incremental change at the current node based on increment_vec.

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

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

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

void	computeIncrementAtQps (const NumericVector< Number > &increment_vec)

void	computeIncrementAtNode (const NumericVector< Number > &increment_vec)

const FieldVariableValue &	sln (Moose::SolutionState state) const
	Local solution getter.

const FieldVariableGradient &	gradSln (Moose::SolutionState state) const
	Local solution gradient getter.

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

void	setNodalValue (const OutputType &value)
	Set nodal value.

void	setNodalValue (const RealVectorValue &value)

void	insert (libMesh::NumericVector< libMesh::Number > &residual)
	Set the current local DOF values to the input vector.

void	insert (NumericVector< Number > &residual)

void	add (libMesh::NumericVector< libMesh::Number > &residual)
	Add the current local DOF values to the input vector.

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.

void	prepareAux ()
	Clear aux state.

void	sizeMatrixTagData ()
	size matrix tag data


void	setDofValue (const DofValue &value, unsigned int index)
	dof value setters

Protected Member Functions
virtual const MooseVariableField< OutputType > &	var () const

void	insertSolutionTag (TagID tag_id)
	insert a solution tag into our tag containers

void	needSolutionState (unsigned int state)
	Request that we have at least `state` number of older solution states/vectors.

void	fetchDofValues ()
	Helper methods for assigning dof values from their corresponding solution values.

void	fetchDofValues ()

void	fetchDofValues ()

void	zeroSizeDofValues ()

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

void	assignNodalValue ()

void	assignNodalValue ()

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.

void	resizeVectorTagData (TagID tag)
	resize the vector tag need flags and data containers to accomodate this tag index

Protected Attributes
SystemBase &	_sys
	The MOOSE system which ultimately holds the vectors and matrices relevant to this variable data.

const SubProblem &	_subproblem
	The subproblem which we can query for information related to tagged vectors and matrices.

const THREAD_ID	_tid
	The thread ID that this object is on.

const libMesh::DofMap &	_dof_map
	The degree of freedom map from libMesh.

unsigned int	_count
	Number of components of the associated variable.

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

unsigned int	_max_state
	The maximum number of older solution states our variable needs.

TagID	_solution_tag
	The vector tag ID corresponding to the solution vector.

TagID	_old_solution_tag
	The vector tag ID corresponding to the old solution vector.

TagID	_older_solution_tag
	The vector tag ID corresponding to the older solution vector.

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

std::vector< dof_id_type >	_dof_indices
	The dof indices for the current element.

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.

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.

MooseArray< OutputType >	_nodal_value_old_array

MooseArray< OutputType >	_nodal_value_older_array

bool	_need_u_dot
	u dot flags

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

bool	_need_grad_dotdot

bool	_need_dof_values_dot
	local solution flags

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

DofValues	_dof_values_dotdot
	second time derivative of the solution values

DofValues	_dof_values_dot_old
	the previous time step's solution value time derivative

DofValues	_dof_values_dotdot_old
	the previous time step's solution value second time derivative

MooseArray< libMesh::Number >	_dof_du_dot_du
	derivatives of the solution value time derivative with respect to the degrees of freedom

MooseArray< libMesh::Number >	_dof_du_dotdot_du
	derivatives of the solution value second time derivative with respect to the degrees of freedom

OutputType	_nodal_value_dot
	nodal values of u_dot

OutputType	_nodal_value_dotdot
	nodal values of u_dotdot

OutputType	_nodal_value_dot_old
	nodal values of u_dot_old

OutputType	_nodal_value_dotdot_old
	nodal values of u_dotdot_old

std::set< TagID >	_required_vector_tags
	The set of vector tags (residual + solution) we need to evaluate.

std::set< TagID >	_solution_tags
	The set of solution tags we need to evaluate.

Private Member Functions
void	fetchADDofValues ()
	Helper method for assigning the ad_dof* arrays.

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

template<bool constant_monomial>
void	computeValuesInternal ()
	Internal method for computeValues() and computeConstantMonomialValues()

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)

void	needADGradPhiFace () const
	Ask the assembly to compute the AD face shape function gradients, which this variable's AD gradient and AD face test function gradients are built from.

void	fetchADDofValues ()

void	assignADNodalValue ()

Private Attributes
const MooseVariableFE< OutputType > &	_var
	A const reference to the owning MooseVariableFE object.

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.

bool	_is_nodal
	if variable is nodal

dof_id_type	_nodal_dof_index
	The dof index for the current node.

libMesh::FEContinuity	_continuity
	Continuity type of the variable.

FieldVariableValue	_increment
	Increment in the variable used in dampers.

Moose::ADType< OutputType >::type	_ad_nodal_value
	AD nodal value.

ADReal	_ad_zero
	A zero AD variable.

bool	_need_second = false
	SolutionState second_u flags.

bool	_need_second_old = false

bool	_need_second_older = false

bool	_need_second_previous_nl = false

bool	_need_curl = false
	curl flags

bool	_need_curl_old = false

bool	_need_curl_older = false

bool	_need_div = false
	divergence flags

bool	_need_div_old = false

bool	_need_div_older = false

bool	_need_ad = false
	AD flags.

bool	_need_ad_volume = false
	Whether AD is needed with the volume quadrature rule.

bool	_need_ad_u = false

bool	_need_ad_grad_u = false

bool	_need_ad_grad_u_face = false
	Whether the AD gradient is needed on element faces, i.e. requested through adGradSlnFace()

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

FieldVariableGradient	_grad_u_dotdot

FieldVariableSecond	_second_u
	second_u

FieldVariableSecond	_second_u_old

FieldVariableSecond	_second_u_older

FieldVariableSecond	_second_u_previous_nl

FieldVariableCurl	_curl_u
	curl_u

FieldVariableCurl	_curl_u_old

FieldVariableCurl	_curl_u_older

FieldVariableDivergence	_div_u
	divergence_u

FieldVariableDivergence	_div_u_old

FieldVariableDivergence	_div_u_older

ADTemplateVariableValue< OutputType >	_ad_u
	AD u.

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)

FieldVariableValue	_u_dotdot
	u_dotdot (second time derivative)

FieldVariableValue	_u_dot_old
	u_dot_old (time derivative)

FieldVariableValue	_u_dotdot_old
	u_dotdot_old (second time derivative)

VariableValue	_du_dot_du
	derivative of u_dot wrt u

VariableValue	_du_dotdot_du
	derivative of u_dotdot wrt u

const QBase *const &	_qrule
	The current qrule.

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.

const Node *const &	_node
	The current node.

const Elem *const &	_elem
	The current elem.

const bool	_displaced
	Whether this variable is being calculated on a displaced system.

const unsigned int &	_current_side
	The current element side.

ADReal	_ad_real_dummy = 0
	A dummy ADReal variable.

Detailed Description

template<typename OutputType>
class MooseVariableData< OutputType >

Definition at line 48 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 60 of file MooseVariableData.h.

◆ FieldVariableDivergence

template<typename OutputType >

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

Definition at line 61 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 75 of file MooseVariableData.h.

◆ FieldVariablePhiDivergence

template<typename OutputType >

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

Definition at line 76 of file MooseVariableData.h.

◆ FieldVariablePhiGradient

template<typename OutputType >

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

Definition at line 73 of file MooseVariableData.h.

◆ FieldVariablePhiSecond

template<typename OutputType >

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

Definition at line 74 of file MooseVariableData.h.

◆ FieldVariablePhiValue

template<typename OutputType >

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

Definition at line 72 of file MooseVariableData.h.

◆ FieldVariableSecond

template<typename OutputType >

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

Definition at line 59 of file MooseVariableData.h.

◆ FieldVariableTestCurl

template<typename OutputType >

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

Definition at line 83 of file MooseVariableData.h.

◆ FieldVariableTestDivergence

template<typename OutputType >

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

Definition at line 84 of file MooseVariableData.h.

◆ FieldVariableTestGradient

template<typename OutputType >

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

Definition at line 81 of file MooseVariableData.h.

◆ FieldVariableTestSecond

template<typename OutputType >

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

Definition at line 82 of file MooseVariableData.h.

◆ FieldVariableTestValue

template<typename OutputType >

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

Definition at line 80 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 64 of file MooseVariableData.h.

◆ OutputShapeDivergence

template<typename OutputType >

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

Definition at line 69 of file MooseVariableData.h.

◆ OutputShapeGradient

template<typename OutputType >

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

Definition at line 67 of file MooseVariableData.h.

◆ OutputShapeSecond

template<typename OutputType >

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

Definition at line 68 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 26 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 381 of file MooseVariableData.h.

  {
    _need_ad = _need_ad_volume = _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 468 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]

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

inherited

Definition at line 479 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 807 of file MooseVariableData.h.

{
  _need_ad = _need_ad_volume = 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 815 of file MooseVariableData.h.

{
  _need_ad = _need_ad_volume = _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 1094 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 868 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 878 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");
  needADGradPhiFace();
  return *_ad_grad_phi_face;
}

◆ adGradSln()

template<typename OutputType >

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

inline

Definition at line 303 of file MooseVariableData.h.

  {
    _need_ad = _need_ad_volume = _need_ad_grad_u = true;
    return _ad_grad_u;
  }

◆ adGradSlnDot()

template<typename OutputType >

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

inline

Volume-only: on element faces the AD gradient time derivative is not computed, because it would require the AD face shape function gradients, and the returned array is left empty.

Definition at line 335 of file MooseVariableData.h.

  {
    _need_ad = _need_ad_volume = _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;
  }

◆ adGradSlnFace()

template<typename OutputType >

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

inline

Face counterpart of adGradSln(); see adSlnFace().

Objects evaluating on element faces must use this accessor: on a face, the AD gradient is only computed when it was requested here.

Definition at line 324 of file MooseVariableData.h.

  {
    _need_ad = _need_ad_grad_u = _need_ad_grad_u_face = true;
    needADGradPhiFace();
    return _ad_grad_u;
  }

◆ adNodalValue()

template<typename OutputType >

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

Definition at line 826 of file MooseVariableData.h.

{
  // _ad_nodal_value is assigned by computeNodalValues(), not by the quadrature-rule path, so
  // this request carries no need for AD with the volume quadrature rule.
  _need_ad = true;
  return _ad_nodal_value;
}

◆ adSecondSln()

template<typename OutputType >

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

inline

Definition at line 349 of file MooseVariableData.h.

  {
    _need_ad = _need_ad_volume = _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 297 of file MooseVariableData.h.

  {
    _need_ad = _need_ad_volume = _need_ad_u = true;
    return _ad_u;
  }

◆ adSlnFace()

template<typename OutputType >

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

inline

Solution getter for objects that only ever evaluate on element faces, such as AD integrated BCs.

Identical to adSln() except that it does not request AD on element interiors, where such an object never reads the result.

Definition at line 314 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 836 of file MooseVariableData.h.

{
  _need_ad = _need_ad_volume = _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 852 of file MooseVariableData.h.

{
  _need_ad = _need_ad_volume = _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 155 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 169 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 1376 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]

void MooseVariableData< RealVectorValue >::assignADNodalValue ( )

private

Definition at line 1384 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 763 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]

void MooseVariableDataBase< RealVectorValue >::assignNodalValue ( )

protectedinherited

◆ assignNodalValue() [3/3]

void MooseVariableDataBase< RealVectorValue >::assignNodalValue ( )

protectedinherited

Definition at line 799 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 425 of file MooseVariableData.h.

425{ _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 798 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. On an element face, only fill the gradient when a face object requested it. Otherwise it
  // stays empty so that a face object that read it through the volume accessor adGradSln() fails
  // the bounds assertion instead of silently using gradients built without the AD face shape
  // function gradients. Neighbor data never uses AD shape function gradients and is not affected.
  const bool on_element_face =
      _element_type == Moose::ElementType::Element && _current_qrule != _qrule;
  if (_need_ad_grad_u && on_element_face && !_need_ad_grad_u_face)
    _ad_grad_u.resize(0);
  else 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];
      }
    }
 
    // The gradient time derivative is volume-only, so on an element face it is left empty for the
    // same reason as the gradient above
    if (_need_ad_grad_u_dot && on_element_face)
      _ad_grad_u_dot.resize(0);
    else 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 699 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 1228 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]

void MooseVariableData< RealEigenVector >::computeIncrementAtNode ( const NumericVector< Number > & increment_vec )

Definition at line 1241 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 1177 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]

void MooseVariableData< RealEigenVector >::computeIncrementAtQps ( const NumericVector< Number > & increment_vec )

Definition at line 1194 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 1357 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 692 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 535 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);
  }
 
  // A variable whose AD was only ever requested through the face-scoped accessors has no
  // consumer on element interiors, so seeding the derivatives there is wasted work. In the
  // volume context _current_qrule is _qrule; see setGeometry().
  if (_need_ad && (_need_ad_volume || _current_qrule != _qrule))
    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 236 of file MooseVariableData.h.

236{ 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 241 of file MooseVariableData.h.

241{ return _need_div || _need_div_old; }

◆ curlPhi()

template<typename OutputType >

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

curl_phi getter

Definition at line 383 of file MooseVariableData.C.

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

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

◆ curlPhiFace()

template<typename OutputType >

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

curl_phi_face getter

Definition at line 391 of file MooseVariableData.C.

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

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

◆ 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 305 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 255 of file MooseVariableData.h.

255{ return _elem; }

◆ currentSide()

template<typename OutputType >

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

inline

The current side.

Definition at line 260 of file MooseVariableData.h.

260{ return _current_side; }

◆ divPhi()

template<typename OutputType >

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

divergence_phi getter

Definition at line 399 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 407 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 336 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 423 of file MooseVariableData.h.

423{ return _dof_indices; }

◆ dofValues()

template<typename OutputType >

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

inherited

Definition at line 354 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Current);
}

◆ dofValuesDot()

template<typename OutputType >

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

Definition at line 1102 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 1116 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 1146 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 1131 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 1169 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 1161 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 361 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Old);
}

◆ dofValuesOlder()

template<typename OutputType >

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

inherited

Definition at line 368 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Older);
}

◆ dofValuesPreviousNL()

template<typename OutputType >

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

inherited

Definition at line 375 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::PreviousNL);
}

◆ duDotDotDu()

template<typename OutputType >

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

inline

Definition at line 375 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 369 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 713 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]

void MooseVariableData< RealEigenVector >::fetchADDofValues ( )

private

Definition at line 769 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 561 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]);
    }
    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();
    }
  }
 
  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)
    {
      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);
          _matrix_tags_dof_u[tag].resize(n);
          for (unsigned i = 0; i < n; i++)
            _matrix_tags_dof_u[tag][i] = mat(_dof_indices[i], _dof_indices[i]);
        }
    }
  }
}

◆ fetchDofValues() [2/3]

void MooseVariableDataBase< RealEigenVector >::fetchDofValues ( )

protectedinherited

◆ fetchDofValues() [3/3]

void MooseVariableDataBase< RealEigenVector >::fetchDofValues ( )

protectedinherited

Definition at line 664 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.solutionUDotDot(), 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 419 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 649 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 247 of file MooseVariableData.h.

247{ return _continuity; };

◆ getDofIndices()

template<typename OutputType >

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

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

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

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

◆ getElementalValue() [2/2]

template<typename OutputType >

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

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

◆ getNodalValue() [1/2]

template<typename OutputType >

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

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

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

Definition at line 975 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 150 of file MooseVariableData.h.

150{ return *_grad_phi; }

◆ gradPhiFace()

template<typename OutputType >

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

inline

grad_phi_face getter

Definition at line 164 of file MooseVariableData.h.

164{ 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 329 of file MooseVariableDataBase.C.

{
  auto functor = [this](TagID tag_id) -> const FieldVariableGradient &
  { return vectorTagGradient(tag_id); };
 
  _var.requireQpComputations();
 
  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 237 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 251 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 246 of file MooseVariableData.h.

246{ return _continuity != libMesh::DISCONTINUOUS; }

libMesh::DISCONTINUOUS

DISCONTINUOUS

◆ increment()

template<typename OutputType >

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

inline

Increment getter.

Returns: The increment

Definition at line 479 of file MooseVariableData.h.

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

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

inherited

Definition at line 449 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 927 of file MooseVariableData.C.

{
  residual.set(_nodal_dof_index, v);
}

◆ insertNodalValue() [2/2]

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

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

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

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

◆ 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 245 of file MooseVariableData.h.

245{ return _is_nodal; }

◆ isNodalDefined()

template<typename OutputType >

bool MooseVariableData< OutputType >::isNodalDefined ( ) const

inline

Definition at line 250 of file MooseVariableData.h.

250{ return _has_dof_indices; }

◆ matrixTagValue()

template<typename OutputType >

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

inherited

Definition at line 232 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);
  }
 
  _var.requireQpComputations();
 
  _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());
}

◆ needADGradPhiFace()

template<typename OutputType >

void MooseVariableData< OutputType >::needADGradPhiFace ( ) const

private

Ask the assembly to compute the AD face shape function gradients, which this variable's AD gradient and AD face test function gradients are built from.

Definition at line 140 of file MooseVariableData.C.

{
  _assembly.needADGradPhiFace();
}

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

◆ needsAD()

template<typename OutputType >

bool MooseVariableData< OutputType >::needsAD ( ) const

inline

Returns whether this data structure needs automatic differentiation calculations.

Definition at line 104 of file MooseVariableData.h.

104{ 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 259 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 249 of file MooseVariableData.h.

249{ return _nodal_dof_index; }

◆ nodalMatrixTagValue()

template<typename OutputType >

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

inherited

Definition at line 123 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 498 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 532 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 1267 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 1289 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 1334 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 1312 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 100 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 248 of file MooseVariableData.h.

248{ return _node; }

◆ numberOfDofs()

template<typename OutputType >

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

inline

Definition at line 424 of file MooseVariableData.h.

424{ 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 252 of file MooseVariableDataBase.C.

{
  return _max_state;
}

◆ phi()

template<typename OutputType >

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

inline

phi getter

Definition at line 140 of file MooseVariableData.h.

140{ return *_phi; }

◆ phiFace()

template<typename OutputType >

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

inline

phi_face getter

Definition at line 145 of file MooseVariableData.h.

145{ return *_phi_face; }

◆ phiFaceSize()

template<typename OutputType >

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

inline

Return phiFace size.

Definition at line 223 of file MooseVariableData.h.

223{ return _phi_face->size(); }

◆ phiSize()

template<typename OutputType >

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

inline

Return phi size.

Definition at line 218 of file MooseVariableData.h.

218{ return _phi->size(); }

◆ prepare()

template<typename OutputType >

void MooseVariableData< OutputType >::prepare ( )

Get the dof indices corresponding to the current element.

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

142{ _has_dof_values = false; }

◆ prepareIC()

template<typename OutputType >

void MooseVariableData< OutputType >::prepareIC ( )

prepare the initial condition

Definition at line 1395 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 1450 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 1429 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 1488 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)
      {
        if constexpr (std::is_same<RealEigenVector, OutputType>::value)
        {
          static thread_local std::vector<dof_id_type> dof_indices;
          _dof_map.array_dof_indices(nd, dof_indices, _var_num);
          for (const auto dof : dof_indices)
            _dof_indices.push_back(dof);
        }
        else
        {
          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 149 of file MooseVariableDataBase.C.

{
  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 367 of file MooseVariableData.C.

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

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

◆ secondPhiFace()

template<typename OutputType >

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

second_phi_face getter

Definition at line 375 of file MooseVariableData.C.

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

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

◆ 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 266 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 889 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 907 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 147 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 )

inherited

Set nodal value.

Definition at line 382 of file MooseVariableDataBase.C.

{
  // dof_values here is indexed per shape function, with each entry holding all _count array
  // components packed into a single OutputType value. setNodalValue writes only one shape
  // function's value, so it is only valid for a variable with a single shape function, e.g. a
  // nodal Lagrange variable or a CONSTANT-order elemental variable; a variable with more than
  // one shape function must use setDofValues instead. A subparametric variable, e.g. the pressure
  // of a Taylor-Hood pair, has nodes on its elements that carry none of its degrees of freedom;
  // callers query isNodalDefined() to skip those nodes before reaching this method.
  mooseAssert(_dof_indices.size() == _count,
              "setNodalValue is only valid for a variable with one shape function per node");
  auto & dof_values = _vector_tags_dof_u[_solution_tag];
  dof_values.resize(/*n_shapes=*/1);
  dof_values[0] = 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]

void MooseVariableDataBase< RealVectorValue >::setNodalValue ( const RealVectorValue & value )

inherited

Definition at line 407 of file MooseVariableDataBase.C.

{
  // Unlike the generic implementation above, a vector-valued variable is never an array
  // variable, so _count is always 1 and dof_values is indexed per component of the vector
  // rather than per shape function -- each shape function contributes one raw degree of
  // freedom per component given the finite element family and order constraints we set below.
  mooseAssert(_count == 1, "Vector-valued variables cannot be array variables");
  mooseAssert(
      _var.feType().family == LAGRANGE_VEC ||
          (_var.feType().family == MONOMIAL_VEC && _var.feType().order == CONSTANT &&
           (!_var.feType().p_refinement || !_subproblem.doingPRefinement())),
      "setNodalValue only makes sense for LAGRANGE_VEC or non-p-refined CONSTANT MONOMIAL_VEC "
      "vector variables");
  mooseAssert(_dof_indices.size() <= _var.sys().mesh().getMesh().mesh_dimension(),
              "The number of dof indices for a vector variable should be at most the mesh manifold "
              "dimension. We cannot use an exact equality because it's possible the vector "
              "variable could live on a lower-dimensional manifold.");
 
  auto & dof_values = _vector_tags_dof_u[_solution_tag];
  dof_values.resize(_dof_indices.size());
  for (const auto i : index_range(dof_values))
    dof_values[i] = 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 87 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 316 of file MooseVariableDataBase.C.

{
  auto functor = [this](TagID tag_id) -> const FieldVariableValue &
  { return vectorTagValue(tag_id); };
 
  _var.requireQpComputations();
 
  return const_cast<MooseVariableDataBase<OutputType> *>(this)
      ->stateToTagHelper<FieldVariableValue>(state, functor);
}

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

◆ 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 271 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 178 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 192 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 222 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 207 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 228 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.

153{ return _var; }

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

◆ vectorTagDofValue() [1/2]

template<typename OutputType >

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

inherited

Definition at line 342 of file MooseVariableDataBase.C.

{
  auto functor = [this](TagID tag_id) -> const DofValues & { return vectorTagDofValue(tag_id); };
 
  _var.requireQpComputations();
 
  return const_cast<MooseVariableDataBase<OutputType> *>(this)->stateToTagHelper<DofValues>(
      state, functor);
}

◆ vectorTagDofValue() [2/2]

template<typename OutputType >

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

inherited

Definition at line 198 of file MooseVariableDataBase.C.

{
  if (tag >= _need_vector_tag_dof_u.size())
    const_cast<MooseVariableDataBase<OutputType> *>(this)->resizeVectorTagData(tag);
 
  _var.requireQpComputations();
 
  _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());
}

◆ vectorTagGradient()

template<typename OutputType >

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

inherited

Definition at line 215 of file MooseVariableDataBase.C.

{
  if (tag >= _need_vector_tag_grad.size())
    const_cast<MooseVariableDataBase<OutputType> *>(this)->resizeVectorTagData(tag);
 
  _var.requireQpComputations();
 
  _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 181 of file MooseVariableDataBase.C.

{
  if (tag >= _need_vector_tag_u.size())
    const_cast<MooseVariableDataBase<OutputType> *>(this)->resizeVectorTagData(tag);
 
  _var.requireQpComputations();
 
  _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 743 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 624 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 616 of file MooseVariableData.h.

◆ _ad_dofs_dot

template<typename OutputType >

ADDofValues MooseVariableData< OutputType >::_ad_dofs_dot

private

Definition at line 617 of file MooseVariableData.h.

◆ _ad_dofs_dot_eigen

template<typename OutputType >

MooseArray<ADRealEigenVector> MooseVariableData< OutputType >::_ad_dofs_dot_eigen

private

Definition at line 618 of file MooseVariableData.h.

◆ _ad_dofs_dotdot

template<typename OutputType >

ADDofValues MooseVariableData< OutputType >::_ad_dofs_dotdot

private

Definition at line 619 of file MooseVariableData.h.

◆ _ad_dofs_dotdot_eigen

template<typename OutputType >

MooseArray<ADRealEigenVector> MooseVariableData< OutputType >::_ad_dofs_dotdot_eigen

private

Definition at line 620 of file MooseVariableData.h.

◆ _ad_grad_phi

template<typename OutputType >

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

private

Definition at line 672 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 724 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 673 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 727 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 614 of file MooseVariableData.h.

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

◆ _ad_grad_u_dot

template<typename OutputType >

ADTemplateVariableGradient<OutputType> MooseVariableData< OutputType >::_ad_grad_u_dot

private

Definition at line 623 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 552 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 749 of file MooseVariableData.h.

◆ _ad_second_u

template<typename OutputType >

ADTemplateVariableSecond<OutputType> MooseVariableData< OutputType >::_ad_second_u

private

Definition at line 615 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 613 of file MooseVariableData.h.

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

◆ _ad_u_dot

template<typename OutputType >

ADTemplateVariableValue<OutputType> MooseVariableData< OutputType >::_ad_u_dot

private

Definition at line 621 of file MooseVariableData.h.

◆ _ad_u_dotdot

template<typename OutputType >

ADTemplateVariableValue<OutputType> MooseVariableData< OutputType >::_ad_u_dotdot

private

Definition at line 622 of file MooseVariableData.h.

◆ _ad_zero

template<typename OutputType >

ADReal MooseVariableData< OutputType >::_ad_zero

private

A zero AD variable.

Definition at line 555 of file MooseVariableData.h.

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

◆ _assembly

template<typename OutputType >

const Assembly& MooseVariableData< OutputType >::_assembly

private

Definition at line 534 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 546 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 656 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 709 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 669 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 712 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 603 of file MooseVariableData.h.

◆ _curl_u_old

template<typename OutputType >

FieldVariableCurl MooseVariableData< OutputType >::_curl_u_old

private

Definition at line 604 of file MooseVariableData.h.

◆ _curl_u_older

template<typename OutputType >

FieldVariableCurl MooseVariableData< OutputType >::_curl_u_older

private

Definition at line 605 of file MooseVariableData.h.

◆ _current_ad_grad_phi

template<typename OutputType >

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

private

Definition at line 681 of file MooseVariableData.h.

◆ _current_curl_phi

template<typename OutputType >

const FieldVariablePhiCurl* MooseVariableData< OutputType >::_current_curl_phi

private

Definition at line 679 of file MooseVariableData.h.

◆ _current_div_phi

template<typename OutputType >

const FieldVariablePhiDivergence* MooseVariableData< OutputType >::_current_div_phi

private

Definition at line 680 of file MooseVariableData.h.

◆ _current_grad_phi

template<typename OutputType >

const FieldVariablePhiGradient* MooseVariableData< OutputType >::_current_grad_phi

private

Definition at line 677 of file MooseVariableData.h.

◆ _current_phi

template<typename OutputType >

const FieldVariablePhiValue* MooseVariableData< OutputType >::_current_phi

private

Definition at line 676 of file MooseVariableData.h.

◆ _current_qrule

template<typename OutputType >

const QBase* MooseVariableData< OutputType >::_current_qrule

private

Definition at line 675 of file MooseVariableData.h.

◆ _current_second_phi

template<typename OutputType >

const FieldVariablePhiSecond* MooseVariableData< OutputType >::_current_second_phi

private

Definition at line 678 of file MooseVariableData.h.

◆ _current_side

template<typename OutputType >

const unsigned int& MooseVariableData< OutputType >::_current_side

private

The current element side.

Definition at line 746 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 743 of file MooseVariableData.h.

◆ _div_phi

template<typename OutputType >

const FieldVariablePhiDivergence* MooseVariableData< OutputType >::_div_phi

mutableprivate

Definition at line 657 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 716 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 670 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 720 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 608 of file MooseVariableData.h.

◆ _div_u_old

template<typename OutputType >

FieldVariableDivergence MooseVariableData< OutputType >::_div_u_old

private

Definition at line 609 of file MooseVariableData.h.

◆ _div_u_older

template<typename OutputType >

FieldVariableDivergence MooseVariableData< OutputType >::_div_u_older

private

Definition at line 610 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 MooseVariableData< OutputType >::clearDofIndices(), MooseVariableDataFV< OutputType >::clearDofIndices(), MooseVariableDataLinearFV< 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 641 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 644 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 740 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 537 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 530 of file MooseVariableData.h.

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

◆ _grad_phi

template<typename OutputType >

const FieldVariablePhiGradient* MooseVariableData< OutputType >::_grad_phi

private

Definition at line 654 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 695 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 667 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 698 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 593 of file MooseVariableData.h.

◆ _grad_u_dotdot

template<typename OutputType >

FieldVariableGradient MooseVariableData< OutputType >::_grad_u_dotdot

private

Definition at line 594 of file MooseVariableData.h.

◆ _has_dof_indices

template<typename OutputType >

bool MooseVariableData< OutputType >::_has_dof_indices

private

Definition at line 590 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 549 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 540 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 660 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 661 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 663 of file MooseVariableData.h.

◆ _mapped_grad_phi_neighbor

template<typename OutputType >

MappedArrayVariablePhiGradient MooseVariableData< OutputType >::_mapped_grad_phi_neighbor

private

Definition at line 662 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 574 of file MooseVariableData.h.

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

◆ _need_ad_curl_u

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_curl_u = false

mutableprivate

Definition at line 585 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 586 of file MooseVariableData.h.

◆ _need_ad_grad_u

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_grad_u = false

mutableprivate

Definition at line 580 of file MooseVariableData.h.

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

◆ _need_ad_grad_u_dot

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_grad_u_dot = false

mutableprivate

Definition at line 583 of file MooseVariableData.h.

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

◆ _need_ad_grad_u_face

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_grad_u_face = false

mutableprivate

Whether the AD gradient is needed on element faces, i.e. requested through adGradSlnFace()

Definition at line 582 of file MooseVariableData.h.

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

◆ _need_ad_second_u

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_second_u = false

mutableprivate

Definition at line 584 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 579 of file MooseVariableData.h.

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

◆ _need_ad_u_dot

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_u_dot = false

mutableprivate

Definition at line 587 of file MooseVariableData.h.

◆ _need_ad_u_dotdot

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_u_dotdot = false

mutableprivate

Definition at line 588 of file MooseVariableData.h.

◆ _need_ad_volume

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_ad_volume = false

mutableprivate

Whether AD is needed with the volume quadrature rule.

Requests made through the face-scoped accessors do not set this, so a variable whose only AD consumers are face objects (an AD integrated BC, for instance) skips AD seeding on element interiors.

Definition at line 578 of file MooseVariableData.h.

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

◆ _need_curl

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_curl = false

mutableprivate

curl flags

Definition at line 564 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 565 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 566 of file MooseVariableData.h.

◆ _need_div

template<typename OutputType >

bool MooseVariableData< OutputType >::_need_div = false

mutableprivate

divergence flags

Definition at line 569 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 570 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 571 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 MooseVariableData< OutputType >::duDotDu(), and MooseVariableDataFV< 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 MooseVariableData< OutputType >::duDotDotDu(), and MooseVariableDataFV< 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 558 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 559 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 560 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 561 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 543 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 735 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 653 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 688 of file MooseVariableData.h.

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

◆ _phi_face

template<typename OutputType >

const FieldVariablePhiValue* MooseVariableData< OutputType >::_phi_face

private

Definition at line 666 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 691 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 649 of file MooseVariableData.h.

◆ _qrule_face

template<typename OutputType >

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

private

Definition at line 650 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 655 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 702 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 668 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 705 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 597 of file MooseVariableData.h.

◆ _second_u_old

template<typename OutputType >

FieldVariableSecond MooseVariableData< OutputType >::_second_u_old

private

Definition at line 598 of file MooseVariableData.h.

◆ _second_u_older

template<typename OutputType >

FieldVariableSecond MooseVariableData< OutputType >::_second_u_older

private

Definition at line 599 of file MooseVariableData.h.

◆ _second_u_previous_nl

template<typename OutputType >

FieldVariableSecond MooseVariableData< OutputType >::_second_u_previous_nl

private

Definition at line 600 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 730 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 629 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 635 of file MooseVariableData.h.

◆ _u_dotdot

template<typename OutputType >

FieldVariableValue MooseVariableData< OutputType >::_u_dotdot

private

u_dotdot (second time derivative)

Definition at line 632 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 638 of file MooseVariableData.h.

◆ _use_dual

template<typename OutputType >

const bool MooseVariableData< OutputType >::_use_dual

private

Definition at line 684 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 528 of file MooseVariableData.h.

◆ _var_num

template<typename OutputType >

const unsigned int MooseVariableData< OutputType >::_var_num

private

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

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ADDofValue

◆ ADDofValues

◆ DofValue

◆ DofValues

◆ FieldVariableCurl

◆ FieldVariableDivergence

◆ FieldVariableGradient

◆ FieldVariablePhiCurl

◆ FieldVariablePhiDivergence

◆ FieldVariablePhiGradient

◆ FieldVariablePhiSecond

◆ FieldVariablePhiValue

◆ FieldVariableSecond

◆ FieldVariableTestCurl

◆ FieldVariableTestDivergence

◆ FieldVariableTestGradient

◆ FieldVariableTestSecond

◆ FieldVariableTestValue

◆ FieldVariableValue

◆ OutputDivergence

◆ OutputGradient

◆ OutputSecond

◆ OutputShape

◆ OutputShapeDivergence

◆ OutputShapeGradient

◆ OutputShapeSecond

Constructor & Destructor Documentation

◆ MooseVariableData()

Member Function Documentation

◆ adCurlSln()

◆ add() [1/2]

◆ add() [2/2]

◆ adDofValues()

◆ adDofValuesDot()

◆ addSolution()

◆ adGradPhi()

◆ adGradPhiFace()

◆ adGradSln()

◆ adGradSlnDot()

◆ adGradSlnFace()

◆ adNodalValue()

◆ adSecondSln()

◆ adSln()

◆ adSlnFace()

◆ adUDot()

◆ adUDotDot()

◆ arrayGradPhi()

◆ arrayGradPhiFace()

◆ assignADNodalValue() [1/2]

◆ assignADNodalValue() [2/2]

◆ assignNodalValue() [1/3]

◆ assignNodalValue() [2/3]

◆ assignNodalValue() [3/3]

◆ clearDofIndices()

◆ computeAD()

◆ computeConstantMonomialValues()

◆ computeIncrementAtNode() [1/2]

◆ computeIncrementAtNode() [2/2]

◆ computeIncrementAtQps() [1/2]

◆ computeIncrementAtQps() [2/2]

◆ computeNodalValues()

◆ computeValues()

◆ computeValuesInternal()

◆ computingCurl()

◆ computingDiv()

◆ curlPhi()

◆ curlPhiFace()

◆ curlSln()

◆ currentElem()

◆ currentSide()

◆ divPhi()

◆ divPhiFace()