#include <MooseVariableData.h>

Inheritance diagram for MooseVariableData< OutputType >:

Public Types
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 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 Moose::DOFType< OutputType >::type	OutputData

typedef MooseArray< OutputData >	DoFValue

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

bool	needsAD () const
	Returns whether this data structure needs automatic differentiation calculations. More...

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

void	computeValues ()
	compute the variable values More...

void	computeMonomialValues ()
	compute the values for const monomial variables More...

void	computeAD (const unsigned int num_dofs, const unsigned int nqp)
	compute AD things More...

void	computeNodalValues ()
	compute nodal things More...

const FieldVariablePhiValue &	phi () const
	phi getter More...

const FieldVariablePhiValue &	phiFace () const
	phi_face getter More...

const FieldVariablePhiGradient &	gradPhi () const
	grad_phi getter More...

const MappedArrayVariablePhiGradient &	arrayGradPhi () const
	mapped_grad_phi getter More...

const FieldVariablePhiGradient &	gradPhiFace () const
	grad_phi_face getter More...

const MappedArrayVariablePhiGradient &	arrayGradPhiFace () const
	mapped_grad_phi_face getter More...

const FieldVariablePhiSecond &	secondPhi () const
	second_phi getter More...

const FieldVariablePhiSecond &	secondPhiFace () const
	second_phi_face getter More...

const FieldVariablePhiCurl &	curlPhi () const
	curl_phi getter More...

const FieldVariablePhiCurl &	curlPhiFace () const
	curl_phi_face getter More...

const FieldVariablePhiDivergence &	divPhi () const
	divergence_phi getter More...

const FieldVariablePhiDivergence &	divPhiFace () const
	divergence_phi_face getter More...

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

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

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

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

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

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

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

bool	isNodal () const override

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

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

const Node *const &	node () const

const dof_id_type &	nodalDofIndex () const

bool	isNodalDefined () const

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

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

void	prepareIC ()
	prepare the initial condition More...

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

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

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

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

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

const ADTemplateVariableValue< OutputType > &	adSln () const

const ADTemplateVariableGradient< OutputType > &	adGradSln () const

const ADTemplateVariableGradient< OutputType > &	adGradSlnDot () const

const ADTemplateVariableSecond< OutputType > &	adSecondSln () const

const ADTemplateVariableValue< OutputType > &	adUDot () const

const ADTemplateVariableValue< OutputType > &	adUDotDot () const

const FieldVariableValue &	uDot () const

const FieldVariableValue &	uDotDot () const

const FieldVariableValue &	uDotOld () const

const FieldVariableValue &	uDotDotOld () const

const VariableValue &	duDotDu () const

const VariableValue &	duDotDotDu () const

const ADTemplateVariableCurl< OutputType > &	adCurlSln () const

const OutputType &	nodalValueDot () const

const OutputType &	nodalValueDotDot () const

const OutputType &	nodalValueDotOld () const

const OutputType &	nodalValueDotDotOld () const

const OutputType &	nodalValueDuDotDu () const

const OutputType &	nodalValueDuDotDotDu () const

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

void	setDofValues (const DenseVector< OutputData > &values)
	Set local DOF values and evaluate the values on quadrature points. More...

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

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

OutputData	getElementalValue (const Elem *elem, Moose::SolutionState state, unsigned int idx=0) const

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

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

unsigned int	numberOfDofs () const

void	clearDofIndices ()

void	prepare ()
	Get the dof indices corresponding to the current element. More...

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

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

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

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

const DoFValue &	dofValuesDot () const

const DoFValue &	dofValuesDotOld () const

const DoFValue &	dofValuesDotDot () const

const DoFValue &	dofValuesDotDotOld () const

const MooseArray< libMesh::Number > &	dofValuesDuDotDu () const

const MooseArray< libMesh::Number > &	dofValuesDuDotDotDu () const

const MooseArray< ADReal > &	adDofValues () const
	Return the AD dof values. More...

const MooseArray< ADReal > &	adDofValuesDot () const
	Return the AD time derivative values of degrees of freedom. More...

const FieldVariableValue &	increment () const
	Increment getter. More...

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

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

template<>
void	computeAD (const unsigned int, const unsigned int)

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

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

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

template<>
void	addSolution (NumericVector< Number > &sol, const DenseVector< Number > &v) const

template<>
void	computeIncrementAtQps (const NumericVector< Number > &increment_vec)

template<>
void	computeIncrementAtNode (const NumericVector< Number > &increment_vec)

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

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

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

void	setNodalValue (const OutputType &value, unsigned int idx=0)
	Set nodal value. More...

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

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

template<>
void	insert (NumericVector< Number > &residual)

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

template<>
void	add (NumericVector< Number > &residual)

const DoFValue &	dofValues () const

const DoFValue &	dofValuesOld () const

const DoFValue &	dofValuesOlder () const

const DoFValue &	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 DoFValue &	nodalVectorTagValue (TagID tag) const

const DoFValue &	nodalMatrixTagValue (TagID tag) const

const DoFValue &	vectorTagDofValue (TagID tag) const

const DoFValue &	vectorTagDofValue (Moose::SolutionState state) const

void	setActiveTags (const std::set< TagID > &vtags)
	Set the active vector tags. More...

void	prepareAux ()
	Clear aux state. More...


void	setDofValue (const OutputData &value, unsigned int index)
	dof value setters More...

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

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

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

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

template<>
void	fetchDoFValues ()

template<>
void	fetchDoFValues ()

void	zeroSizeDofValues ()

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

void	assignNodalValue ()

template<>
void	assignNodalValue ()

template<>
void	assignNodalValue ()

template<typename ReturnType , typename Functor >
const ReturnType &	stateToTagHelper (Moose::SolutionState state, Functor functor)
	Helper method that converts a `SolutionState` argument into a corresponding tag ID, potentially requesting necessary additional solution states and assigning tag id data members, and then calls the provided `functor` with the tag ID. More...

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

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

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

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

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

unsigned int	_count
	Number of components of the associated variable. More...

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

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

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

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

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

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

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

std::vector< bool >	_need_vector_tag_dof_u

std::vector< bool >	_need_matrix_tag_dof_u

std::vector< DoFValue >	_vector_tags_dof_u

std::vector< DoFValue >	_matrix_tags_dof_u

std::vector< FieldVariableValue >	_vector_tag_u

std::vector< bool >	_need_vector_tag_u

std::vector< FieldVariableGradient >	_vector_tag_grad

std::vector< bool >	_need_vector_tag_grad

std::vector< FieldVariableValue >	_matrix_tag_u

std::vector< bool >	_need_matrix_tag_u

OutputType	_nodal_value
	Nodal values. More...

OutputType	_nodal_value_old

OutputType	_nodal_value_older

OutputType	_nodal_value_previous_nl

MooseArray< OutputType >	_nodal_value_array
	Nodal values as MooseArrays for use with AuxKernels. More...

MooseArray< OutputType >	_nodal_value_old_array

MooseArray< OutputType >	_nodal_value_older_array

bool	_need_u_dot
	u dot flags More...

bool	_need_u_dotdot

bool	_need_u_dot_old

bool	_need_u_dotdot_old

bool	_need_du_dot_du

bool	_need_du_dotdot_du

bool	_need_grad_dot
	gradient dot flags More...

bool	_need_grad_dotdot

bool	_need_dof_values_dot
	local solution flags More...

bool	_need_dof_values_dotdot

bool	_need_dof_values_dot_old

bool	_need_dof_values_dotdot_old

bool	_need_dof_du_dot_du

bool	_need_dof_du_dotdot_du

DoFValue	_dof_values_dot
	time derivative of the solution values More...

DoFValue	_dof_values_dotdot
	second time derivative of the solution values More...

DoFValue	_dof_values_dot_old
	the previous time step's solution value time derivative More...

DoFValue	_dof_values_dotdot_old
	the previous time step's solution value second time derivative More...

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

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

OutputType	_nodal_value_dot
	nodal values of u_dot More...

OutputType	_nodal_value_dotdot
	nodal values of u_dotdot More...

OutputType	_nodal_value_dot_old
	nodal values of u_dot_old More...

OutputType	_nodal_value_dotdot_old
	nodal values of u_dotdot_old More...

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

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

Private Member Functions
void	assignADNodalValue (const ADReal &value, const unsigned int &component)
	Helper methods for assigning nodal values from their corresponding solution values (dof values as they're referred to here in this class). More...

void	fetchADNodalValues ()

template<bool monomial>
void	computeValuesInternal ()
	Internal method for computeValues() and computeMonomialValues() More...

template<>
void	fetchADNodalValues ()

template<>
void	assignADNodalValue (const ADReal &value, const unsigned int &)

template<>
void	assignADNodalValue (const ADReal &value, const unsigned int &component)

Private Attributes
const libMesh::FEType &	_fe_type

const unsigned int	_var_num

const Assembly &	_assembly

Moose::ElementType	_element_type
	The element type this object is storing data for. This is either Element, Neighbor, or Lower. More...

bool	_is_nodal
	if variable is nodal More...

dof_id_type	_nodal_dof_index
	The dof index for the current node. More...

libMesh::FEContinuity	_continuity
	Continuity type of the variable. More...

FieldVariableValue	_increment
	Increment in the variable used in dampers. More...

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

ADReal	_ad_zero
	A zero AD variable. More...

bool	_need_ad_u_dot
	AD u dot flags. More...

bool	_need_ad_u_dotdot

bool	_need_second
	SolutionState second_u flags. More...

bool	_need_second_old

bool	_need_second_older

bool	_need_second_previous_nl

bool	_need_curl
	curl flags More...

bool	_need_curl_old

bool	_need_curl_older

bool	_need_div
	divergence flags More...

bool	_need_div_old

bool	_need_div_older

bool	_need_ad
	AD flags. More...

bool	_need_ad_u

bool	_need_ad_grad_u

bool	_need_ad_grad_u_dot

bool	_need_ad_second_u

bool	_need_ad_curl_u

bool	_has_dof_indices

FieldVariableGradient	_grad_u_dot
	grad_u dots More...

FieldVariableGradient	_grad_u_dotdot

FieldVariableSecond	_second_u
	second_u More...

FieldVariableSecond	_second_u_old

FieldVariableSecond	_second_u_older

FieldVariableSecond	_second_u_previous_nl

FieldVariableCurl	_curl_u
	curl_u More...

FieldVariableCurl	_curl_u_old

FieldVariableCurl	_curl_u_older

FieldVariableDivergence	_div_u
	divergence_u More...

FieldVariableDivergence	_div_u_old

FieldVariableDivergence	_div_u_older

ADTemplateVariableValue< OutputType >	_ad_u
	AD u. More...

ADTemplateVariableGradient< OutputType >	_ad_grad_u

ADTemplateVariableSecond< OutputType >	_ad_second_u

MooseArray< ADReal >	_ad_dof_values

MooseArray< ADReal >	_ad_dofs_dot

MooseArray< ADReal >	_ad_dofs_dotdot

ADTemplateVariableValue< OutputType >	_ad_u_dot

ADTemplateVariableValue< OutputType >	_ad_u_dotdot

ADTemplateVariableGradient< OutputType >	_ad_grad_u_dot

ADTemplateVariableCurl< OutputType >	_ad_curl_u

FieldVariableValue	_u_dot
	u_dot (time derivative) More...

FieldVariableValue	_u_dotdot
	u_dotdot (second time derivative) More...

FieldVariableValue	_u_dot_old
	u_dot_old (time derivative) More...

FieldVariableValue	_u_dotdot_old
	u_dotdot_old (second time derivative) More...

VariableValue	_du_dot_du
	derivative of u_dot wrt u More...

VariableValue	_du_dotdot_du
	derivative of u_dotdot wrt u More...

const QBase *const &	_qrule
	The current qrule. More...

const QBase *const &	_qrule_face

const FieldVariablePhiValue *	_phi

const FieldVariablePhiGradient *	_grad_phi

const FieldVariablePhiSecond *	_second_phi

const FieldVariablePhiCurl *	_curl_phi

const FieldVariablePhiDivergence *	_div_phi

MappedArrayVariablePhiGradient	_mapped_grad_phi

MappedArrayVariablePhiGradient	_mapped_grad_phi_face

MappedArrayVariablePhiGradient	_mapped_grad_phi_neighbor

MappedArrayVariablePhiGradient	_mapped_grad_phi_face_neighbor

const FieldVariablePhiValue *	_phi_face

const FieldVariablePhiGradient *	_grad_phi_face

const FieldVariablePhiSecond *	_second_phi_face

const FieldVariablePhiCurl *	_curl_phi_face

const FieldVariablePhiDivergence *	_div_phi_face

const ADTemplateVariablePhiGradient< OutputShape > *	_ad_grad_phi

const ADTemplateVariablePhiGradient< OutputShape > *	_ad_grad_phi_face

const QBase *	_current_qrule

const FieldVariablePhiValue *	_current_phi

const FieldVariablePhiGradient *	_current_grad_phi

const FieldVariablePhiSecond *	_current_second_phi

const FieldVariablePhiCurl *	_current_curl_phi

const FieldVariablePhiDivergence *	_current_div_phi

const ADTemplateVariablePhiGradient< OutputShape > *	_current_ad_grad_phi

const bool	_use_dual

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

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

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

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

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

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

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

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

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

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

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

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

const TimeIntegrator *	_time_integrator
	Pointer to time integrator. More...

const Node *const &	_node
	The current node. More...

const Elem *const &	_elem
	The current elem. More...

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

const unsigned int &	_current_side
	The current element side. More...

ADReal	_ad_real_dummy = 0
	A dummy ADReal variable. More...

Detailed Description

template<typename OutputType>
class MooseVariableData< OutputType >

Definition at line 49 of file MooseVariableData.h.

Member Typedef Documentation

◆ DoFValue

template<typename OutputType>

typedef MooseArray<OutputData> MooseVariableData< OutputType >::DoFValue

Definition at line 89 of file MooseVariableData.h.

◆ FieldVariableCurl

template<typename OutputType>

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

Definition at line 61 of file MooseVariableData.h.

◆ FieldVariableDivergence

template<typename OutputType>

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

Definition at line 62 of file MooseVariableData.h.

◆ FieldVariableGradient

template<typename OutputType>

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

Definition at line 59 of file MooseVariableData.h.

◆ FieldVariablePhiCurl

template<typename OutputType>

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

Definition at line 76 of file MooseVariableData.h.

◆ FieldVariablePhiDivergence

template<typename OutputType>

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

Definition at line 77 of file MooseVariableData.h.

◆ FieldVariablePhiGradient

template<typename OutputType>

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

Definition at line 74 of file MooseVariableData.h.

◆ FieldVariablePhiSecond

template<typename OutputType>

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

Definition at line 75 of file MooseVariableData.h.

◆ FieldVariablePhiValue

template<typename OutputType>

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

Definition at line 73 of file MooseVariableData.h.

◆ FieldVariableSecond

template<typename OutputType>

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

Definition at line 60 of file MooseVariableData.h.

◆ FieldVariableTestCurl

template<typename OutputType>

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

Definition at line 84 of file MooseVariableData.h.

◆ FieldVariableTestDivergence

template<typename OutputType>

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

Definition at line 85 of file MooseVariableData.h.

◆ FieldVariableTestGradient

template<typename OutputType>

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

Definition at line 82 of file MooseVariableData.h.

◆ FieldVariableTestSecond

template<typename OutputType>

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

Definition at line 83 of file MooseVariableData.h.

◆ FieldVariableTestValue

template<typename OutputType>

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

Definition at line 81 of file MooseVariableData.h.

◆ FieldVariableValue

template<typename OutputType>

typedef MooseArray<OutputType> MooseVariableData< OutputType >::FieldVariableValue

Definition at line 58 of file MooseVariableData.h.

◆ OutputData

template<typename OutputType>

typedef Moose::DOFType<OutputType>::type MooseVariableData< OutputType >::OutputData

Definition at line 88 of file MooseVariableData.h.

◆ OutputDivergence

template<typename OutputType>

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

Definition at line 55 of file MooseVariableData.h.

◆ OutputGradient

template<typename OutputType>

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

Definition at line 53 of file MooseVariableData.h.

◆ OutputSecond

template<typename OutputType>

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

Definition at line 54 of file MooseVariableData.h.

◆ OutputShape

template<typename OutputType>

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

Definition at line 65 of file MooseVariableData.h.

◆ OutputShapeDivergence

template<typename OutputType>

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

Definition at line 70 of file MooseVariableData.h.

◆ OutputShapeGradient

template<typename OutputType>

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

Definition at line 68 of file MooseVariableData.h.

◆ OutputShapeSecond

template<typename OutputType>

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

Definition at line 69 of file MooseVariableData.h.

Constructor & Destructor Documentation

◆ MooseVariableData()

template<typename OutputType>

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

Definition at line 28 of file MooseVariableData.C.

   : MooseVariableDataBase<OutputType>(var, sys, tid),
     _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),
     _need_ad_u_dot(false),
     _need_ad_u_dotdot(false),
     _need_second(false),
     _need_second_old(false),
     _need_second_older(false),
     _need_second_previous_nl(false),
     _need_curl(false),
     _need_curl_old(false),
     _need_curl_older(false),
     _need_div(false),
     _need_div_old(false),
     _need_div_older(false),
     _need_ad(false),
     _need_ad_u(false),
     _need_ad_grad_u(false),
     _need_ad_grad_u_dot(false),
     _need_ad_second_u(false),
     _need_ad_curl_u(false),
     _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 353 of file MooseVariableData.h.

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

◆ add() [1/2]

template<typename OutputType>

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

inherited

Add the current local DOF values to the input vector.

Definition at line 429 of file MooseVariableDataBase.C.

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

◆ add() [2/2]

template<>

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

inherited

Definition at line 440 of file MooseVariableDataBase.C.

 {
   if (_has_dof_values)
   {
     auto & dof_values = _vector_tags_dof_u[_solution_tag];
     if (isNodal())
     {
       for (unsigned int i = 0; i < _dof_indices.size(); ++i)
         for (unsigned int j = 0; j < _count; ++j)
           residual.add(_dof_indices[i] + j, dof_values[i](j));
     }
     else
     {
       unsigned int n = 0;
       for (unsigned int j = 0; j < _count; ++j)
       {
         for (unsigned int i = 0; i < _dof_indices.size(); ++i)
           residual.add(_dof_indices[i] + n, dof_values[i](j));
         n += _dof_indices.size();
       }
     }
   }
 }

◆ adDofValues()

template<typename OutputType >

const MooseArray< ADReal > & MooseVariableData< OutputType >::adDofValues ( ) const

Return the AD dof values.

Definition at line 750 of file MooseVariableData.h.

 {
   _need_ad = true;
   return _ad_dof_values;
 }

◆ adDofValuesDot()

template<typename OutputType >

const MooseArray< ADReal > & MooseVariableData< OutputType >::adDofValuesDot ( ) const

Return the AD time derivative values of degrees of freedom.

Definition at line 758 of file MooseVariableData.h.

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

◆ addSolution() [1/2]

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

 {
   sol.add_vector(v, _dof_indices);
 }

◆ addSolution() [2/2]

template<>

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

Definition at line 1043 of file MooseVariableData.C.

 {
   unsigned int p = 0;
   const auto num_dofs = _dof_indices.size();
   for (const auto j : make_range(_count))
   {
     unsigned int inc = (isNodal() ? j : j * num_dofs);
     for (const auto i : make_range(num_dofs))
       sol.add(_dof_indices[i] + inc, v(p++));
   }
 }

◆ adGradPhi()

template<typename OutputType >

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

ad_grad_phi getter

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

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

◆ adGradSln()

template<typename OutputType>

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

inline

Definition at line 301 of file MooseVariableData.h.

   {
     _need_ad = _need_ad_grad_u = true;
     return _ad_grad_u;
   }

◆ adGradSlnDot()

template<typename OutputType>

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

inline

Definition at line 307 of file MooseVariableData.h.

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

◆ adNodalValue()

template<typename OutputType >

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

Definition at line 769 of file MooseVariableData.h.

 {
   _need_ad = true;
   return _ad_nodal_value;
 }

◆ adSecondSln()

template<typename OutputType>

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

inline

Definition at line 321 of file MooseVariableData.h.

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

◆ adSln()

template<typename OutputType>

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

inline

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

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

◆ adUDotDot()

template<typename OutputType >

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

Definition at line 793 of file MooseVariableData.h.

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

◆ arrayGradPhi()

template<typename OutputType>

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

inline

mapped_grad_phi getter

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

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

◆ assignADNodalValue() [1/3]

template<typename OutputType>

void MooseVariableData< OutputType >::assignADNodalValue	(	const ADReal &	value,
		const unsigned int &	component
	)

private

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

These methods are only truly meaningful for nodal basis families

◆ assignADNodalValue() [2/3]

template<>

void MooseVariableData< Real >::assignADNodalValue	(	const ADReal &	value,
		const unsigned int &
	)

private

Definition at line 1379 of file MooseVariableData.C.

 {
   _ad_nodal_value = value;
 }

◆ assignADNodalValue() [3/3]

template<>

void MooseVariableData< RealVectorValue >::assignADNodalValue	(	const ADReal &	value,
		const unsigned int &	component
	)

private

Definition at line 1386 of file MooseVariableData.C.

 {
   _ad_nodal_value(component) = value;
 }

◆ assignNodalValue() [1/3]

template<typename OutputType >

void MooseVariableDataBase< OutputType >::assignNodalValue ( )

protectedinherited

Definition at line 746 of file MooseVariableDataBase.C.

 {
   bool is_transient = _subproblem.isTransient();
 
   libmesh_assert(_dof_indices.size());
 
   auto & dof_values = _vector_tags_dof_u[_solution_tag];
   _nodal_value = dof_values[0];
   _nodal_value_array[0] = _nodal_value;
 
   if (is_transient)
   {
     if (oldestSolutionStateRequested() >= 1)
     {
       _nodal_value_old = _vector_tags_dof_u[_old_solution_tag][0];
       _nodal_value_old_array[0] = _nodal_value_old;
     }
     if (oldestSolutionStateRequested() >= 2)
     {
       _nodal_value_older = _vector_tags_dof_u[_older_solution_tag][0];
       _nodal_value_older_array[0] = _nodal_value_older;
     }
     if (_need_dof_values_dot)
       _nodal_value_dot = _dof_values_dot[0];
     if (_need_dof_values_dotdot)
       _nodal_value_dotdot = _dof_values_dotdot[0];
     if (_need_dof_values_dot_old)
       _nodal_value_dot_old = _dof_values_dot_old[0];
     if (_need_dof_values_dotdot_old)
       _nodal_value_dotdot_old = _dof_values_dotdot_old[0];
   }
   if (_previous_nl_solution_tag != Moose::INVALID_TAG_ID)
     _nodal_value_previous_nl = _vector_tags_dof_u[_previous_nl_solution_tag][0];
 }

◆ assignNodalValue() [2/3]

template<>

void MooseVariableDataBase< RealVectorValue >::assignNodalValue ( )

protectedinherited

◆ assignNodalValue() [3/3]

template<>

void MooseVariableDataBase< RealVectorValue >::assignNodalValue ( )

protectedinherited

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

397 { _dof_indices.clear(); }

MooseVariableDataBase::_dof_indices

std::vector< dof_id_type > _dof_indices

The dof indices for the current element.

Definition: MooseVariableDataBase.h:217

◆ computeAD() [1/2]

template<typename OutputType >

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

compute AD things

Definition at line 681 of file MooseVariableData.C.

 {
   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] = (*_sys.currentSolution())(_dof_indices[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.);
 
   if (_need_ad_u)
   {
     _ad_u.resize(nqp);
     for (const auto qp : make_range(nqp))
       _ad_u[qp] = _ad_zero;
 
     for (const auto i : make_range(num_dofs))
       for (const auto qp : make_range(nqp))
         _ad_u[qp] += _ad_dof_values[i] * (*_current_phi)[i][qp];
   }
 
   if (_need_ad_grad_u)
   {
     _ad_grad_u.resize(nqp);
     for (const auto qp : make_range(nqp))
       _ad_grad_u[qp] = _ad_zero;
 
     // 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)
       for (const auto i : make_range(num_dofs))
         for (const auto qp : make_range(nqp))
           _ad_grad_u[qp] += _ad_dof_values[i] * (*_current_ad_grad_phi)[i][qp];
     else
       for (const auto i : make_range(num_dofs))
         for (const auto qp : make_range(nqp))
           _ad_grad_u[qp] += _ad_dof_values[i] * (*_current_grad_phi)[i][qp];
   }
 
   if (_need_ad_second_u)
   {
     _ad_second_u.resize(nqp);
     for (const auto qp : make_range(nqp))
       _ad_second_u[qp] = _ad_zero;
 
     for (const auto i : make_range(num_dofs))
       for (const auto qp : make_range(nqp))
         // Note that this will not carry any derivatives with respect to displacements because
         // those calculations have not yet been implemented in Assembly
         _ad_second_u[qp] += _ad_dof_values[i] * (*_current_second_phi)[i][qp];
   }
 
   if (_need_ad_curl_u)
   {
     _ad_curl_u.resize(nqp);
     for (const auto qp : make_range(nqp))
       _ad_curl_u[qp] = _ad_zero;
 
     for (const auto i : make_range(num_dofs))
       for (const auto qp : make_range(nqp))
       {
         mooseAssert(_current_curl_phi,
                     "We're requiring a curl calculation but have not set a curl shape function!");
 
         // Note that the current version of _ad_curl_u is not yet implemented for mesh displacement
         _ad_curl_u[qp] += _ad_dof_values[i] * (*_current_curl_phi)[i][qp];
       }
   }
 
   bool is_transient = _subproblem.isTransient();
   if (is_transient)
   {
     if (_need_ad_u_dot)
     {
       _ad_dofs_dot.resize(num_dofs);
       if (_need_ad_u_dotdot)
         _ad_dofs_dotdot.resize(num_dofs);
       _ad_u_dot.resize(nqp);
       for (const auto qp : make_range(nqp))
         _ad_u_dot[qp] = _ad_zero;
 
       if (_time_integrator && _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);
 
         for (const auto i : make_range(num_dofs))
           for (const auto qp : make_range(nqp))
             _ad_u_dot[qp] += (*_current_phi)[i][qp] * _ad_dofs_dot[i];
       }
       else if (!_time_integrator)
       {
         for (const auto i : make_range(num_dofs))
           _ad_dofs_dot[i] = _dof_values_dot[i];
         for (const auto qp : make_range(nqp))
           _ad_u_dot[qp] = _u_dot[qp];
       }
     }
 
     if (_need_ad_u_dotdot)
     {
       _ad_u_dotdot.resize(nqp);
       for (const auto qp : make_range(nqp))
         _ad_u_dotdot[qp] = _ad_zero;
 
       if (_time_integrator && _time_integrator->dt())
         for (const auto i : make_range(num_dofs))
           for (const auto qp : make_range(nqp))
             _ad_u_dotdot[qp] += (*_current_phi)[i][qp] * _ad_dofs_dotdot[i];
       else if (!_time_integrator)
         for (const auto qp : make_range(nqp))
           _ad_u_dotdot[qp] = _u_dotdot[qp];
     }
 
     if (_need_ad_grad_u_dot)
     {
       _ad_grad_u_dot.resize(nqp);
       for (const auto qp : make_range(nqp))
         _ad_grad_u_dot[qp] = _ad_zero;
 
       if (_time_integrator && _time_integrator->dt())
       {
         // 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)
           for (const auto i : make_range(num_dofs))
             for (const auto qp : make_range(nqp))
               _ad_grad_u_dot[qp] += _ad_dofs_dot[i] * (*_current_ad_grad_phi)[i][qp];
         else
           for (const auto i : make_range(num_dofs))
             for (const auto qp : make_range(nqp))
               _ad_grad_u_dot[qp] += _ad_dofs_dot[i] * (*_current_grad_phi)[i][qp];
       }
       else if (!_time_integrator)
         for (const auto qp : make_range(nqp))
           _ad_grad_u_dot[qp] = _grad_u_dot[qp];
     }
   }
 }

◆ computeAD() [2/2]

template<>

void MooseVariableData< RealEigenVector >::computeAD	(	const unsigned	int,
		const unsigned	int
	)

Definition at line 832 of file MooseVariableData.C.

 {
   mooseError("AD for array variable has not been implemented");
 }

◆ 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 1184 of file MooseVariableData.C.

 {
   if (!isNodal())
     mooseError("computeIncrementAtNode can only be called for nodal variables");
 
   _increment.resize(1);
 
   // Compute the increment for the current DOF
   _increment[0] = increment_vec(_dof_indices[0]);
 }

◆ computeIncrementAtNode() [2/2]

template<>

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

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

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

◆ computeIncrementAtQps() [2/2]

template<>

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

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

◆ computeMonomialValues()

template<typename OutputType >

void MooseVariableData< OutputType >::computeMonomialValues ( )

compute the values for const monomial variables

Definition at line 667 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</* monomial = */ true>();
 }

◆ computeNodalValues()

template<typename OutputType >

void MooseVariableData< OutputType >::computeNodalValues ( )

compute nodal things

Definition at line 1313 of file MooseVariableData.C.

 {
   if (_has_dof_indices)
   {
     fetchDoFValues();
     assignNodalValue();
 
     if (_need_ad)
       fetchADNodalValues();
   }
   else
     zeroSizeDofValues();
 }

◆ computeValues()

template<typename OutputType >

void MooseVariableData< OutputType >::computeValues ( )

compute the variable values

Definition at line 660 of file MooseVariableData.C.

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

◆ computeValuesInternal()

template<typename OutputType >

template<bool monomial>

void MooseVariableData< OutputType >::computeValuesInternal ( )

private

Internal method for computeValues() and computeMonomialValues()

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

Definition at line 428 of file MooseVariableData.C.

 {
   const auto num_dofs = _dof_indices.size();
   if (num_dofs > 0)
     fetchDoFValues();
 
   const bool is_transient = _subproblem.isTransient();
   const auto nqp = _current_qrule->n_points();
   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_dofs);
       for (const auto i : make_range(num_dofs))
       {
         _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_dofs);
       for (const auto i : make_range(num_dofs))
       {
         _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!");
 
   // Helper for filling values
   const auto fill = [this, nqp, num_dofs](auto & dest, const auto & phi, const auto & dof_values)
   {
     if constexpr (monomial)
       libmesh_ignore(num_dofs);
 
     // 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>;
     constexpr bool is_gradient = std::is_same_v<dest_array_type, OutputGradient>;
     constexpr bool is_second = std::is_same_v<dest_array_type, OutputSecond>;
     constexpr bool is_divergence = std::is_same_v<dest_array_type, OutputDivergence>;
     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 (monomial)
     {
       mooseAssert(num_dofs == 1, "Should have only one dof");
       set_zero(0);
       accumulate(0, 0);
       for (unsigned int qp = 1; qp < nqp; ++qp)
         dest[qp] = dest[0];
     }
     // Non monomial case
     else
     {
       for (const auto qp : make_range(nqp))
         set_zero(qp);
       for (const auto i : make_range(num_dofs))
         for (const auto qp : make_range(nqp))
           accumulate(i, qp);
     }
   };
 
   // Curl
   if (_need_curl)
     fill(_curl_u, *_current_curl_phi, _vector_tags_dof_u[_solution_tag]);
   if (_need_curl_old)
     fill(_curl_u_old, *_current_curl_phi, _vector_tags_dof_u[_old_solution_tag]);
 
   // Div
   if (_need_div)
     fill(_div_u, *_current_div_phi, _vector_tags_dof_u[_solution_tag]);
   if (is_transient && _need_div_old)
     fill(_div_u_old, *_current_div_phi, _vector_tags_dof_u[_old_solution_tag]);
 
   // Second
   if (_need_second)
     fill(_second_u, *_current_second_phi, _vector_tags_dof_u[_solution_tag]);
   if (_need_second_previous_nl)
     fill(
         _second_u_previous_nl, *_current_second_phi, _vector_tags_dof_u[_previous_nl_solution_tag]);
 
   // Vector tags
   for (auto tag : _required_vector_tags)
   {
     if (_need_vector_tag_u[tag] && _sys.hasVector(tag) && _sys.getVector(tag).closed())
       fill(_vector_tag_u[tag], *_current_phi, _vector_tags_dof_u[tag]);
     if (_need_vector_tag_grad[tag] && _sys.hasVector(tag) && _sys.getVector(tag).closed())
       fill(_vector_tag_grad[tag], *_current_grad_phi, _vector_tags_dof_u[tag]);
   }
 
   // Matrix tags
   for (auto tag : active_coupleable_matrix_tags)
     if (_need_matrix_tag_u[tag])
       fill(_matrix_tag_u[tag], *_current_phi, _matrix_tags_dof_u[tag]);
 
   // Derivatives and old values
   if (is_transient)
   {
     if (_need_second_old)
       fill(_second_u_old, *_current_second_phi, _vector_tags_dof_u[_old_solution_tag]);
     if (_need_second_older)
       fill(_second_u_older, *_current_second_phi, _vector_tags_dof_u[_older_solution_tag]);
     if (_need_u_dot)
       fill(_u_dot, *_current_phi, _dof_values_dot);
     if (_need_u_dotdot)
       fill(_u_dotdot, *_current_phi, _dof_values_dotdot);
     if (_need_u_dot_old)
       fill(_u_dot_old, *_current_phi, _dof_values_dot_old);
     if (_need_u_dotdot_old)
       fill(_u_dotdot_old, *_current_phi, _dof_values_dotdot_old);
 
     if (_need_du_dot_du)
     {
       _du_dot_du.resize(nqp);
       for (const auto qp : make_range(nqp))
         _du_dot_du[qp] = 0.;
       for (const auto i : make_range(num_dofs))
         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 qp : make_range(nqp))
         _du_dotdot_du[qp] = 0.;
       for (const auto i : make_range(num_dofs))
         for (const auto qp : make_range(nqp))
           _du_dotdot_du[qp] = _dof_du_dotdot_du[i];
     }
 
     if (_need_grad_dot)
       fill(_grad_u_dot, *_current_grad_phi, _dof_values_dot);
     if (_need_grad_dotdot)
       fill(_grad_u_dotdot, *_current_grad_phi, _dof_values_dotdot);
   }
 
   // Automatic differentiation, not for eigen
   if constexpr (!std::is_same_v<OutputType, RealEigenVector>)
     if (_need_ad)
       computeAD(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 234 of file MooseVariableData.h.

234 { return _need_curl || _need_curl_old; }

MooseVariableData::_need_curl_old

bool _need_curl_old

Definition: MooseVariableData.h:520

MooseVariableData::_need_curl

bool _need_curl

curl flags

Definition: MooseVariableData.h:519

◆ computingDiv()

template<typename OutputType>

bool MooseVariableData< OutputType >::computingDiv ( ) const

inline

Whether or not this variable is computing the divergence.

Definition at line 239 of file MooseVariableData.h.

239 { return _need_div || _need_div_old; }

MooseVariableData::_need_div

bool _need_div

divergence flags

Definition: MooseVariableData.h:524

MooseVariableData::_need_div_old

bool _need_div_old

Definition: MooseVariableData.h:525

◆ curlPhi()

template<typename OutputType >

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

curl_phi getter

Definition at line 395 of file MooseVariableData.C.

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

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

◆ curlPhiFace()

template<typename OutputType >

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

curl_phi_face getter

Definition at line 403 of file MooseVariableData.C.

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

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

◆ curlSln()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariableCurl & MooseVariableData< OutputType >::curlSln ( Moose::SolutionState state ) const

Local solution curl getter.

Parameters

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

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

253 { return _elem; }

MooseVariableData::_elem

const Elem *const & _elem

The current elem.

Definition: MooseVariableData.h:684

◆ currentSide()

template<typename OutputType>

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

inline

The current side.

Definition at line 258 of file MooseVariableData.h.

258 { return _current_side; }

MooseVariableData::_current_side

const unsigned int & _current_side

The current element side.

Definition: MooseVariableData.h:690

◆ divPhi()

template<typename OutputType >

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

divergence_phi getter

Definition at line 411 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 419 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 348 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 395 of file MooseVariableData.h.

395 { return _dof_indices; }

MooseVariableDataBase::_dof_indices

std::vector< dof_id_type > _dof_indices

The dof indices for the current element.

Definition: MooseVariableDataBase.h:217

◆ dofValues()

template<typename OutputType >

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

inherited

Definition at line 333 of file MooseVariableDataBase.C.

 {
   return vectorTagDofValue(Moose::Current);
 }

◆ dofValuesDot()

template<typename OutputType >

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

Definition at line 1058 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 >::DoFValue & MooseVariableData< OutputType >::dofValuesDotDot ( ) const

Definition at line 1072 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 >::DoFValue & MooseVariableData< OutputType >::dofValuesDotDotOld ( ) const

Definition at line 1102 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 >::DoFValue & MooseVariableData< OutputType >::dofValuesDotOld ( ) const

Definition at line 1087 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 1125 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 1117 of file MooseVariableData.C.

 {
   _need_dof_du_dot_du = true;
   return _dof_du_dot_du;
 }

◆ dofValuesOld()

template<typename OutputType >

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

inherited

Definition at line 340 of file MooseVariableDataBase.C.

 {
   return vectorTagDofValue(Moose::Old);
 }

◆ dofValuesOlder()

template<typename OutputType >

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

inherited

Definition at line 347 of file MooseVariableDataBase.C.

 {
   return vectorTagDofValue(Moose::Older);
 }

◆ dofValuesPreviousNL()

template<typename OutputType >

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

inherited

Definition at line 354 of file MooseVariableDataBase.C.

 {
   return vectorTagDofValue(Moose::PreviousNL);
 }

◆ duDotDotDu()

template<typename OutputType>

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

inline

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

   {
     _need_du_dot_du = true;
     return _du_dot_du;
   }

◆ fetchADNodalValues() [1/2]

template<typename OutputType >

void MooseVariableData< OutputType >::fetchADNodalValues ( )

private

Definition at line 1329 of file MooseVariableData.C.

 {
   auto n = _dof_indices.size();
   libmesh_assert(n);
   _ad_dof_values.resize(n);
 
   if (_need_ad_u_dot)
     _ad_dofs_dot.resize(n);
   if (_need_ad_u_dotdot)
     _ad_dofs_dotdot.resize(n);
 
   const bool do_derivatives =
       ADReal::do_derivatives && _sys.number() == _subproblem.currentNlSysNum();
 
   for (decltype(n) i = 0; i < n; ++i)
   {
     _ad_dof_values[i] = _vector_tags_dof_u[_solution_tag][i];
     if (do_derivatives)
       Moose::derivInsert(_ad_dof_values[i].derivatives(), _dof_indices[i], 1.);
     assignADNodalValue(_ad_dof_values[i], i);
 
     if (_need_ad_u_dot)
     {
       if (_time_integrator && _time_integrator->dt())
       {
         _ad_dofs_dot[i] = _ad_dof_values[i];
         _time_integrator->computeADTimeDerivatives(_ad_dofs_dot[i],
                                                    _dof_indices[i],
                                                    _need_ad_u_dotdot ? _ad_dofs_dotdot[i]
                                                                      : _ad_real_dummy);
       }
       // Executing something with a time derivative at initial should not put a NaN
       else if (_time_integrator && !_time_integrator->dt())
         _ad_dofs_dot[i] = 0.;
       else
         mooseError("AD nodal time derivatives not implemented for variables without a time "
                    "integrator (auxiliary variables)");
     }
   }
 }

◆ fetchADNodalValues() [2/2]

template<>

void MooseVariableData< RealEigenVector >::fetchADNodalValues ( )

private

Definition at line 1372 of file MooseVariableData.C.

 {
   mooseError("I do not know how to support AD with array variables");
 }

◆ 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 529 of file MooseVariableDataBase.C.

 {
   bool is_transient = _subproblem.isTransient();
 
   auto n = _dof_indices.size();
   libmesh_assert(n);
 
   if (is_transient)
   {
     if (_need_u_dot || _need_grad_dot || _need_dof_values_dot)
     {
       libmesh_assert(_sys.solutionUDot());
       _dof_values_dot.resize(n);
       _sys.solutionUDot()->get(_dof_indices, &_dof_values_dot[0]);
     }
     if (_need_u_dotdot || _need_grad_dotdot || _need_dof_values_dotdot)
     {
       libmesh_assert(_sys.solutionUDotDot());
       _dof_values_dotdot.resize(n);
       _sys.solutionUDotDot()->get(_dof_indices, &_dof_values_dotdot[0]);
     }
     if (_need_u_dot_old || _need_dof_values_dot_old)
     {
       libmesh_assert(_sys.solutionUDotOld());
       _dof_values_dot_old.resize(n);
       _sys.solutionUDotOld()->get(_dof_indices, &_dof_values_dot_old[0]);
     }
     if (_need_u_dotdot_old || _need_dof_values_dotdot_old)
     {
       libmesh_assert(_sys.solutionUDotDotOld());
       _dof_values_dotdot_old.resize(n);
       _sys.solutionUDotDotOld()->get(_dof_indices, &_dof_values_dotdot_old[0]);
     }
   }
 
   for (auto tag : _required_vector_tags)
     if (_need_vector_tag_u[tag] || _need_vector_tag_grad[tag] || _need_vector_tag_dof_u[tag])
       if ((_subproblem.vectorTagType(tag) == Moose::VECTOR_TAG_RESIDUAL &&
            _subproblem.safeAccessTaggedVectors()) ||
           _subproblem.vectorTagType(tag) == Moose::VECTOR_TAG_SOLUTION)
       {
         // tag is defined on problem but may not be used by a system
         // the grain tracker requires being able to read from solution vectors that we are also in
         // the process of writing :-/
         if (_sys.hasVector(tag) /* && _sys.getVector(tag).closed()*/)
         {
           auto & vec = _sys.getVector(tag);
           _vector_tags_dof_u[tag].resize(n);
           vec.get(_dof_indices, &_vector_tags_dof_u[tag][0]);
         }
       }
 
   if (_subproblem.safeAccessTaggedMatrices())
   {
     auto & active_coupleable_matrix_tags =
         _subproblem.getActiveFEVariableCoupleableMatrixTags(_tid);
 
     for (auto tag : active_coupleable_matrix_tags)
     {
       _matrix_tags_dof_u[tag].resize(n);
       if (_need_matrix_tag_dof_u[tag] || _need_matrix_tag_u[tag])
         if (_sys.hasMatrix(tag) && _sys.matrixTagActive(tag) && _sys.getMatrix(tag).closed())
         {
           auto & mat = _sys.getMatrix(tag);
           for (unsigned i = 0; i < n; i++)
           {
             Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
             _matrix_tags_dof_u[tag][i] = mat(_dof_indices[i], _dof_indices[i]);
           }
         }
     }
   }
 
   if (_need_du_dot_du || _need_dof_du_dot_du)
   {
     _dof_du_dot_du.resize(n);
     for (decltype(n) i = 0; i < n; ++i)
       _dof_du_dot_du[i] = _sys.duDotDu(_var.number());
   }
   if (_need_du_dotdot_du || _need_dof_du_dotdot_du)
   {
     _dof_du_dotdot_du.resize(n);
     for (decltype(n) i = 0; i < n; ++i)
       _dof_du_dotdot_du[i] = _sys.duDotDotDu();
   }
 }

◆ fetchDoFValues() [2/3]

template<>

void MooseVariableDataBase< RealEigenVector >::fetchDoFValues ( )

protectedinherited

◆ fetchDoFValues() [3/3]

template<>

void MooseVariableDataBase< RealEigenVector >::fetchDoFValues ( )

protectedinherited

Definition at line 650 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());
       getArrayDoFValues(*_sys.solutionUDot(), n, _dof_values_dot);
     }
     if (_need_u_dotdot || _need_grad_dotdot || _need_dof_values_dotdot)
     {
       libmesh_assert(_sys.solutionUDotDot());
       getArrayDoFValues(*_sys.solutionUDot(), n, _dof_values_dotdot);
     }
     if (_need_u_dot_old || _need_dof_values_dot_old)
     {
       libmesh_assert(_sys.solutionUDotOld());
       getArrayDoFValues(*_sys.solutionUDotOld(), n, _dof_values_dot_old);
     }
     if (_need_u_dotdot_old || _need_dof_values_dotdot_old)
     {
       libmesh_assert(_sys.solutionUDotDotOld());
       getArrayDoFValues(*_sys.solutionUDotDotOld(), n, _dof_values_dotdot_old);
     }
   }
 
   for (auto tag : _required_vector_tags)
     if ((_subproblem.vectorTagType(tag) == Moose::VECTOR_TAG_RESIDUAL &&
          _subproblem.safeAccessTaggedVectors()) ||
         _subproblem.vectorTagType(tag) == Moose::VECTOR_TAG_SOLUTION)
       // tag is defined on problem but may not be used by a system
       if (_sys.hasVector(tag) && _sys.getVector(tag).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) && _sys.getMatrix(tag).closed())
         {
           auto & mat = _sys.getMatrix(tag);
           for (unsigned i = 0; i < n; i++)
           {
             Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
             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();
   }
 }

◆ 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 618 of file MooseVariableDataBase.C.

 {
   dof_values.resize(n);
   if (isNodal())
   {
     for (unsigned int i = 0; i < n; ++i)
     {
       dof_values[i].resize(_count);
       auto dof = _dof_indices[i];
       for (unsigned int j = 0; j < _count; ++j)
         dof_values[i](j) = sol(dof++);
     }
   }
   else
   {
     for (unsigned int i = 0; i < n; ++i)
     {
       dof_values[i].resize(_count);
       auto dof = _dof_indices[i];
       for (unsigned int j = 0; j < _count; ++j)
       {
         dof_values[i](j) = sol(dof);
         dof += n;
       }
     }
   }
 }

◆ getContinuity()

template<typename OutputType>

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

inlineoverridevirtual

Return the variable continuity.

Implements MooseVariableDataBase< OutputType >.

Definition at line 245 of file MooseVariableData.h.

245 { return _continuity; };

MooseVariableData::_continuity

libMesh::FEContinuity _continuity

Continuity type of the variable.

Definition: MooseVariableData.h:497

◆ getDofIndices()

template<typename OutputType>

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

Definition at line 1027 of file MooseVariableData.C.

 {
   _dof_map.dof_indices(elem, dof_indices, _var_num);
 }

◆ getElementalValue() [1/2]

template<typename OutputType>

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

Definition at line 966 of file MooseVariableData.C.

 {
   std::vector<dof_id_type> dof_indices;
   _dof_map.dof_indices(elem, dof_indices, _var_num);
 
   switch (state)
   {
     case Moose::Current:
       return (*_sys.currentSolution())(dof_indices[idx]);
 
     case Moose::Old:
       return _sys.solutionOld()(dof_indices[idx]);
 
     case Moose::Older:
       return _sys.solutionOlder()(dof_indices[idx]);
 
     default:
       mooseError("PreviousNL not currently supported for getElementalValue");
   }
 }

◆ getElementalValue() [2/2]

template<>

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

Definition at line 991 of file MooseVariableData.C.

 {
   std::vector<dof_id_type> dof_indices;
   _dof_map.dof_indices(elem, dof_indices, _var_num);
 
   dof_id_type dof = dof_indices[idx];
 
   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 getElementalValue");
   }
   return v;
 }

◆ getNodalValue() [1/2]

template<typename OutputType>

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

Definition at line 895 of file MooseVariableData.C.

 {
   mooseAssert(_subproblem.mesh().isSemiLocal(const_cast<Node *>(&node)), "Node is not Semilocal");
 
   // Make sure that the node has DOFs
   /* Note, this is a reproduction of an assert within libMesh::Node::dof_number, this is done to
    * produce a better error (see misc/check_error.node_value_off_block) */
   mooseAssert(node.n_dofs(_sys.number(), _var_num) > 0,
               "Node " << node.id() << " does not contain any dofs for the "
                       << _sys.system().variable_name(_var_num) << " variable");
 
   dof_id_type dof = node.dof_number(_sys.number(), _var_num, 0);
 
   switch (state)
   {
     case Moose::Current:
       return (*_sys.currentSolution())(dof);
 
     case Moose::Old:
       return _sys.solutionOld()(dof);
 
     case Moose::Older:
       return _sys.solutionOlder()(dof);
 
     default:
       mooseError("PreviousNL not currently supported for getNodalValue");
   }
 }

◆ getNodalValue() [2/2]

template<>

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

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

148 { return *_grad_phi; }

MooseVariableData::_grad_phi

const FieldVariablePhiGradient * _grad_phi

Definition: MooseVariableData.h:598

◆ gradPhiFace()

template<typename OutputType>

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

inline

grad_phi_face getter

Definition at line 162 of file MooseVariableData.h.

162 { return *_grad_phi_face; }

MooseVariableData::_grad_phi_face

const FieldVariablePhiGradient * _grad_phi_face

Definition: MooseVariableData.h:611

◆ 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 312 of file MooseVariableDataBase.C.

 {
   auto functor = [this](TagID tag_id) -> const FieldVariableGradient &
   { return vectorTagGradient(tag_id); };
 
   return const_cast<MooseVariableDataBase<OutputType> *>(this)
       ->stateToTagHelper<FieldVariableGradient>(state, functor);
 }

◆ gradSlnDot()

template<typename OutputType >

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

Local time derivative of solution gradient getter.

Definition at line 249 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 263 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 244 of file MooseVariableData.h.

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

libMesh::DISCONTINUOUS

DISCONTINUOUS

MooseVariableData::_continuity

libMesh::FEContinuity _continuity

Continuity type of the variable.

Definition: MooseVariableData.h:497

◆ increment()

template<typename OutputType>

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

inline

Increment getter.

Returns: The increment

Definition at line 451 of file MooseVariableData.h.

451 { return _increment; }

MooseVariableData::_increment

FieldVariableValue _increment

Increment in the variable used in dampers.

Definition: MooseVariableData.h:500

◆ 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 390 of file MooseVariableDataBase.C.

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

◆ insert() [2/2]

template<>

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

inherited

Definition at line 403 of file MooseVariableDataBase.C.

 {
   if (_has_dof_values)
   {
     auto & dof_values = _vector_tags_dof_u[_solution_tag];
     if (isNodal())
     {
       for (unsigned int i = 0; i < _dof_indices.size(); ++i)
         for (unsigned int j = 0; j < _count; ++j)
           residual.set(_dof_indices[i] + j, dof_values[i](j));
     }
     else
     {
       unsigned int n = 0;
       for (unsigned int j = 0; j < _count; ++j)
       {
         for (unsigned int i = 0; i < _dof_indices.size(); ++i)
           residual.set(_dof_indices[i] + n, dof_values[i](j));
         n += _dof_indices.size();
       }
     }
   }
 }

◆ insertNodalValue() [1/2]

template<typename OutputType>

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

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

Definition at line 878 of file MooseVariableData.C.

 {
   residual.set(_nodal_dof_index, v);
 }

◆ insertNodalValue() [2/2]

template<>

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

Definition at line 886 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 323 of file MooseVariableDataBase.h.

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

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

◆ isNodal()

template<typename OutputType>

bool MooseVariableData< OutputType >::isNodal ( ) const

inlineoverridevirtual

Returns: Whether this data is associated with a nodal variable

Implements MooseVariableDataBase< OutputType >.

Definition at line 243 of file MooseVariableData.h.

243 { return _is_nodal; }

MooseVariableData::_is_nodal

bool _is_nodal

if variable is nodal

Definition: MooseVariableData.h:491

◆ isNodalDefined()

template<typename OutputType>

bool MooseVariableData< OutputType >::isNodalDefined ( ) const

inline

Definition at line 248 of file MooseVariableData.h.

248 { return _has_dof_indices; }

MooseVariableData::_has_dof_indices

bool _has_dof_indices

Definition: MooseVariableData.h:536

◆ matrixTagValue()

template<typename OutputType >

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

inherited

Definition at line 219 of file MooseVariableDataBase.C.

 {
   if (tag >= _matrix_tag_u.size())
   {
     _need_matrix_tag_u.resize(tag + 1, false);
     const_cast<MooseVariableDataBase<OutputType> *>(this)->_matrix_tag_u.resize(tag + 1);
   }
 
   _need_matrix_tag_u[tag] = true;
 
   if (_sys.hasMatrix(tag))
     return _matrix_tag_u[tag];
   else
     mooseError("Tag ", tag, " is not associated with any matrix for variable ", _var.name());
 }

◆ needsAD()

template<typename OutputType>

bool MooseVariableData< OutputType >::needsAD ( ) const

inline

Returns whether this data structure needs automatic differentiation calculations.

Definition at line 103 of file MooseVariableData.h.

103 { return _need_ad; }

MooseVariableData::_need_ad

bool _need_ad

AD flags.

Definition: MooseVariableData.h:529

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

247 { return _nodal_dof_index; }

MooseVariableData::_nodal_dof_index

dof_id_type _nodal_dof_index

The dof index for the current node.

Definition: MooseVariableData.h:494

◆ nodalMatrixTagValue()

template<typename OutputType >

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

inherited

Definition at line 116 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 466 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 500 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 1223 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 1245 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 1290 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 1268 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 >::DoFValue & MooseVariableDataBase< OutputType >::nodalVectorTagValue ( TagID tag ) const

inherited

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

246 { return _node; }

MooseVariableData::_node

const Node *const & _node

The current node.

Definition: MooseVariableData.h:679

◆ numberOfDofs()

template<typename OutputType>

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

inline

Definition at line 396 of file MooseVariableData.h.

396 { return _dof_indices.size(); }

MooseVariableDataBase::_dof_indices

std::vector< dof_id_type > _dof_indices

The dof indices for the current element.

Definition: MooseVariableDataBase.h:217

◆ 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 237 of file MooseVariableDataBase.C.

 {
   return _max_state;
 }

◆ phi()

template<typename OutputType>

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

inline

phi getter

Definition at line 138 of file MooseVariableData.h.

138 { return *_phi; }

MooseVariableData::_phi

const FieldVariablePhiValue * _phi

Definition: MooseVariableData.h:597

◆ phiFace()

template<typename OutputType>

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

inline

phi_face getter

Definition at line 143 of file MooseVariableData.h.

143 { return *_phi_face; }

MooseVariableData::_phi_face

const FieldVariablePhiValue * _phi_face

Definition: MooseVariableData.h:610

◆ phiFaceSize()

template<typename OutputType>

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

inline

Return phiFace size.

Definition at line 221 of file MooseVariableData.h.

221 { return _phi_face->size(); }

MooseArray::size

unsigned int size() const

The number of elements that can currently be stored in the array.

Definition: MooseArray.h:259

MooseVariableData::_phi_face

const FieldVariablePhiValue * _phi_face

Definition: MooseVariableData.h:610

◆ phiSize()

template<typename OutputType>

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

inline

Return phi size.

Definition at line 216 of file MooseVariableData.h.

216 { return _phi->size(); }

MooseArray::size

unsigned int size() const

The number of elements that can currently be stored in the array.

Definition: MooseArray.h:259

MooseVariableData::_phi

const FieldVariablePhiValue * _phi

Definition: MooseVariableData.h:597

◆ prepare()

template<typename OutputType >

void MooseVariableData< OutputType >::prepare ( )

Get the dof indices corresponding to the current element.

Definition at line 1405 of file MooseVariableData.C.

 {
   _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 140 of file MooseVariableDataBase.h.

140 { _has_dof_values = false; }

MooseVariableDataBase::_has_dof_values

bool _has_dof_values

Whether we currently have degree of freedom values stored in our local containers (corresponding to t...

Definition: MooseVariableDataBase.h:199

◆ prepareIC()

template<typename OutputType >

void MooseVariableData< OutputType >::prepareIC ( )

prepare the initial condition

Definition at line 1394 of file MooseVariableData.C.

 {
   _dof_map.dof_indices(_elem, _dof_indices, _var_num);
   _vector_tags_dof_u[_solution_tag].resize(_dof_indices.size());
 
   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 1438 of file MooseVariableData.C.

 {
   /* FIXME: this method is only for elemental auxiliary variables, so
    * we may want to rename it */
   if (_elem)
   {
     _dof_map.dof_indices(_elem, _dof_indices, _var_num);
     if (_elem->n_dofs(_sys.number(), _var_num) > 0)
     {
       // FIXME: check if the following is equivalent with '_nodal_dof_index = _dof_indices[0];'?
       _nodal_dof_index = _elem->dof_number(_sys.number(), _var_num, 0);
 
       fetchDoFValues();
 
       const auto num_dofs = _dof_indices.size();
       for (auto & dof_u : _vector_tags_dof_u)
         dof_u.resize(num_dofs);
 
       for (auto & dof_u : _matrix_tags_dof_u)
         dof_u.resize(num_dofs);
 
       _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 1417 of file MooseVariableData.C.

 {
   if (std::size_t n_dofs = _node->n_dofs(_sys.number(), _var_num))
   {
     _dof_indices.resize(n_dofs);
     for (std::size_t i = 0; i < n_dofs; ++i)
       _dof_indices[i] = _node->dof_number(_sys.number(), _var_num, i);
     // 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
   {
     _dof_indices.clear(); // Clear these so Assembly doesn't think there's dofs here
     _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 1470 of file MooseVariableData.C.

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

◆ resizeVectorTagData()

template<typename OutputType >

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

protectedinherited

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

Definition at line 142 of file MooseVariableDataBase.C.

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

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

◆ secondPhi()

template<typename OutputType >

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

second_phi getter

Definition at line 379 of file MooseVariableData.C.

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

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

◆ secondPhiFace()

template<typename OutputType >

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

second_phi_face getter

Definition at line 387 of file MooseVariableData.C.

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

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

◆ secondSln()

template<typename OutputType >

const MooseVariableData< OutputType >::FieldVariableSecond & MooseVariableData< OutputType >::secondSln ( Moose::SolutionState state ) const

Local solution second spatial derivative getter.

Parameters

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

Definition at line 278 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 307 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 OutputData &	value,
		unsigned int	index
	)

dof value setters

Definition at line 840 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< OutputData > & values )

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

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

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

◆ setNodalValue() [1/2]

template<typename OutputType >

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

inherited

Set nodal value.

Definition at line 361 of file MooseVariableDataBase.C.

 {
   auto & dof_values = _vector_tags_dof_u[_solution_tag];
   mooseAssert(idx < dof_values.size(), "idx is out of the bounds of degree of freedom values");
   dof_values[idx] = value; // update variable nodal value
   _has_dof_values = true;
   _nodal_value = value;
 
   // Update the qp values as well
   auto & u = _vector_tag_u[_solution_tag];
   for (unsigned int qp = 0; qp < u.size(); qp++)
     u[qp] = value;
 }

◆ setNodalValue() [2/2]

template<>

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

inherited

Definition at line 377 of file MooseVariableDataBase.C.

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

◆ 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 301 of file MooseVariableDataBase.C.

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

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

◆ stateToTagHelper()

template<typename OutputType >

template<typename ReturnType , typename Functor >

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

protectedinherited

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

Definition at line 256 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 190 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 204 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 234 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 219 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 226 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 146 of file MooseVariableDataBase.h.

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

146 { return _var; }

MooseVariableDataBase::_var

const MooseVariableField< OutputType > & _var

A const reference to the owning MooseVariableField object.

Definition: MooseVariableDataBase.h:296

◆ vectorTagDofValue() [1/2]

template<typename OutputType >

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

inherited

Definition at line 189 of file MooseVariableDataBase.C.

 {
   if (tag >= _need_vector_tag_dof_u.size())
     const_cast<MooseVariableDataBase<OutputType> *>(this)->resizeVectorTagData(tag);
 
   _need_vector_tag_dof_u[tag] = true;
 
   if (_sys.hasVector(tag))
     return _vector_tags_dof_u[tag];
   else
     mooseError("Tag ", tag, " is not associated with any vector for variable ", _var.name());
 }

◆ vectorTagDofValue() [2/2]

template<typename OutputType >

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

inherited

Definition at line 323 of file MooseVariableDataBase.C.

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

◆ vectorTagGradient()

template<typename OutputType >

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

inherited

Definition at line 204 of file MooseVariableDataBase.C.

 {
   if (tag >= _need_vector_tag_grad.size())
     const_cast<MooseVariableDataBase<OutputType> *>(this)->resizeVectorTagData(tag);
 
   _need_vector_tag_grad[tag] = true;
 
   if (_sys.hasVector(tag))
     return _vector_tag_grad[tag];
   else
     mooseError("Tag ", tag, " is not associated with any vector for variable ", _var.name());
 }

◆ vectorTagValue()

template<typename OutputType >

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

inherited

Definition at line 174 of file MooseVariableDataBase.C.

 {
   if (tag >= _need_vector_tag_u.size())
     const_cast<MooseVariableDataBase<OutputType> *>(this)->resizeVectorTagData(tag);
 
   _need_vector_tag_u[tag] = true;
 
   if (_sys.hasVector(tag))
     return _vector_tag_u[tag];
   else
     mooseError("Tag ", tag, " is not associated with any vector for variable ", _var.name());
 }

◆ zeroSizeDofValues()

template<typename OutputType >

void MooseVariableDataBase< OutputType >::zeroSizeDofValues ( )

protectedinherited

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

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

◆ _ad_dof_values

template<typename OutputType>

MooseArray<ADReal> MooseVariableData< OutputType >::_ad_dof_values

private

Definition at line 562 of file MooseVariableData.h.

◆ _ad_dofs_dot

template<typename OutputType>

MooseArray<ADReal> MooseVariableData< OutputType >::_ad_dofs_dot

private

Definition at line 563 of file MooseVariableData.h.

◆ _ad_dofs_dotdot

template<typename OutputType>

MooseArray<ADReal> MooseVariableData< OutputType >::_ad_dofs_dotdot

private

Definition at line 564 of file MooseVariableData.h.

◆ _ad_grad_phi

template<typename OutputType>

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

private

Definition at line 616 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 668 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 617 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 671 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 560 of file MooseVariableData.h.

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

◆ _ad_grad_u_dot

template<typename OutputType>

ADTemplateVariableGradient<OutputType> MooseVariableData< OutputType >::_ad_grad_u_dot

private

Definition at line 567 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 503 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 693 of file MooseVariableData.h.

◆ _ad_second_u

template<typename OutputType>

ADTemplateVariableSecond<OutputType> MooseVariableData< OutputType >::_ad_second_u

private

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

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

◆ _ad_u_dot

template<typename OutputType>

ADTemplateVariableValue<OutputType> MooseVariableData< OutputType >::_ad_u_dot

private

Definition at line 565 of file MooseVariableData.h.

◆ _ad_u_dotdot

template<typename OutputType>

ADTemplateVariableValue<OutputType> MooseVariableData< OutputType >::_ad_u_dotdot

private

Definition at line 566 of file MooseVariableData.h.

◆ _ad_zero

template<typename OutputType>

ADReal MooseVariableData< OutputType >::_ad_zero

private

A zero AD variable.

Definition at line 506 of file MooseVariableData.h.

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

◆ _assembly

template<typename OutputType>

const Assembly& MooseVariableData< OutputType >::_assembly

private

Definition at line 485 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 497 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 195 of file MooseVariableDataBase.h.

◆ _curl_phi

template<typename OutputType>

const FieldVariablePhiCurl* MooseVariableData< OutputType >::_curl_phi

mutableprivate

Definition at line 600 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 653 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 613 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 656 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 549 of file MooseVariableData.h.

◆ _curl_u_old

template<typename OutputType>

FieldVariableCurl MooseVariableData< OutputType >::_curl_u_old

private

Definition at line 550 of file MooseVariableData.h.

◆ _curl_u_older

template<typename OutputType>

FieldVariableCurl MooseVariableData< OutputType >::_curl_u_older

private

Definition at line 551 of file MooseVariableData.h.

◆ _current_ad_grad_phi

template<typename OutputType>

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

private

Definition at line 625 of file MooseVariableData.h.

◆ _current_curl_phi

template<typename OutputType>

const FieldVariablePhiCurl* MooseVariableData< OutputType >::_current_curl_phi

private

Definition at line 623 of file MooseVariableData.h.

◆ _current_div_phi

template<typename OutputType>

const FieldVariablePhiDivergence* MooseVariableData< OutputType >::_current_div_phi

private

Definition at line 624 of file MooseVariableData.h.

◆ _current_grad_phi

template<typename OutputType>

const FieldVariablePhiGradient* MooseVariableData< OutputType >::_current_grad_phi

private

Definition at line 621 of file MooseVariableData.h.

◆ _current_phi

template<typename OutputType>

const FieldVariablePhiValue* MooseVariableData< OutputType >::_current_phi

private

Definition at line 620 of file MooseVariableData.h.

◆ _current_qrule

template<typename OutputType>

const QBase* MooseVariableData< OutputType >::_current_qrule

private

Definition at line 619 of file MooseVariableData.h.

◆ _current_second_phi

template<typename OutputType>

const FieldVariablePhiSecond* MooseVariableData< OutputType >::_current_second_phi

private

Definition at line 622 of file MooseVariableData.h.

◆ _current_side

template<typename OutputType>

const unsigned int& MooseVariableData< OutputType >::_current_side

private

The current element side.

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

◆ _div_phi

template<typename OutputType>

const FieldVariablePhiDivergence* MooseVariableData< OutputType >::_div_phi

mutableprivate

Definition at line 601 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 660 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 614 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 664 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 554 of file MooseVariableData.h.

◆ _div_u_old

template<typename OutputType>

FieldVariableDivergence MooseVariableData< OutputType >::_div_u_old

private

Definition at line 555 of file MooseVariableData.h.

◆ _div_u_older

template<typename OutputType>

FieldVariableDivergence MooseVariableData< OutputType >::_div_u_older

private

Definition at line 556 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 274 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 277 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 217 of file MooseVariableDataBase.h.

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

◆ _dof_map

template<typename OutputType>

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

protectedinherited

The degree of freedom map from libMesh.

Definition at line 192 of file MooseVariableDataBase.h.

◆ _dof_values_dot

template<typename OutputType>

DoFValue MooseVariableDataBase< OutputType >::_dof_values_dot

protectedinherited

time derivative of the solution values

Definition at line 266 of file MooseVariableDataBase.h.

◆ _dof_values_dot_old

template<typename OutputType>

DoFValue MooseVariableDataBase< OutputType >::_dof_values_dot_old

protectedinherited

the previous time step's solution value time derivative

Definition at line 270 of file MooseVariableDataBase.h.

◆ _dof_values_dotdot

template<typename OutputType>

DoFValue MooseVariableDataBase< OutputType >::_dof_values_dotdot

protectedinherited

second time derivative of the solution values

Definition at line 268 of file MooseVariableDataBase.h.

◆ _dof_values_dotdot_old

template<typename OutputType>

DoFValue MooseVariableDataBase< OutputType >::_dof_values_dotdot_old

protectedinherited

the previous time step's solution value second time derivative

Definition at line 272 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 585 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 588 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 684 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 488 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 481 of file MooseVariableData.h.

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

◆ _grad_phi

template<typename OutputType>

const FieldVariablePhiGradient* MooseVariableData< OutputType >::_grad_phi

private

Definition at line 598 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 639 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 611 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 642 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 539 of file MooseVariableData.h.

◆ _grad_u_dotdot

template<typename OutputType>

FieldVariableGradient MooseVariableData< OutputType >::_grad_u_dotdot

private

Definition at line 540 of file MooseVariableData.h.

◆ _has_dof_indices

template<typename OutputType>

bool MooseVariableData< OutputType >::_has_dof_indices

private

Definition at line 536 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 199 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 500 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 491 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 604 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 605 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 607 of file MooseVariableData.h.

◆ _mapped_grad_phi_neighbor

template<typename OutputType>

MappedArrayVariablePhiGradient MooseVariableData< OutputType >::_mapped_grad_phi_neighbor

private

Definition at line 606 of file MooseVariableData.h.

◆ _matrix_tag_u

template<typename OutputType>

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

protectedinherited

Definition at line 231 of file MooseVariableDataBase.h.

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

◆ _matrix_tags_dof_u

template<typename OutputType>

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

protectedinherited

Definition at line 225 of file MooseVariableDataBase.h.

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

◆ _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 202 of file MooseVariableDataBase.h.

◆ _need_ad

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_ad

mutableprivate

AD flags.

Definition at line 529 of file MooseVariableData.h.

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

◆ _need_ad_curl_u

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_ad_curl_u

mutableprivate

Definition at line 534 of file MooseVariableData.h.

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

◆ _need_ad_grad_u

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_ad_grad_u

mutableprivate

Definition at line 531 of file MooseVariableData.h.

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

◆ _need_ad_grad_u_dot

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_ad_grad_u_dot

mutableprivate

Definition at line 532 of file MooseVariableData.h.

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

◆ _need_ad_second_u

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_ad_second_u

mutableprivate

Definition at line 533 of file MooseVariableData.h.

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

◆ _need_ad_u

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_ad_u

mutableprivate

Definition at line 530 of file MooseVariableData.h.

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

◆ _need_ad_u_dot

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_ad_u_dot

mutableprivate

AD u dot flags.

Definition at line 509 of file MooseVariableData.h.

◆ _need_ad_u_dotdot

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_ad_u_dotdot

mutableprivate

Definition at line 510 of file MooseVariableData.h.

◆ _need_curl

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_curl

mutableprivate

curl flags

Definition at line 519 of file MooseVariableData.h.

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

◆ _need_curl_old

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_curl_old

mutableprivate

Definition at line 520 of file MooseVariableData.h.

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

◆ _need_curl_older

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_curl_older

mutableprivate

Definition at line 521 of file MooseVariableData.h.

◆ _need_div

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_div

mutableprivate

divergence flags

Definition at line 524 of file MooseVariableData.h.

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

◆ _need_div_old

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_div_old

mutableprivate

Definition at line 525 of file MooseVariableData.h.

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

◆ _need_div_older

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_div_older

mutableprivate

Definition at line 526 of file MooseVariableData.h.

◆ _need_dof_du_dot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_du_dot_du

mutableprotectedinherited

Definition at line 262 of file MooseVariableDataBase.h.

◆ _need_dof_du_dotdot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_du_dotdot_du

mutableprotectedinherited

Definition at line 263 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 258 of file MooseVariableDataBase.h.

◆ _need_dof_values_dot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dot_old

mutableprotectedinherited

Definition at line 260 of file MooseVariableDataBase.h.

◆ _need_dof_values_dotdot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dotdot

mutableprotectedinherited

Definition at line 259 of file MooseVariableDataBase.h.

◆ _need_dof_values_dotdot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dotdot_old

mutableprotectedinherited

Definition at line 261 of file MooseVariableDataBase.h.

◆ _need_du_dot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_du_dot_du

mutableprotectedinherited

Definition at line 250 of file MooseVariableDataBase.h.

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

◆ _need_du_dotdot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_du_dotdot_du

mutableprotectedinherited

Definition at line 251 of file MooseVariableDataBase.h.

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

◆ _need_grad_dot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_grad_dot

mutableprotectedinherited

gradient dot flags

Definition at line 254 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 255 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 220 of file MooseVariableDataBase.h.

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

◆ _need_matrix_tag_u

template<typename OutputType>

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

mutableprotectedinherited

Definition at line 232 of file MooseVariableDataBase.h.

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

◆ _need_second

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_second

mutableprivate

SolutionState second_u flags.

Definition at line 513 of file MooseVariableData.h.

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

◆ _need_second_old

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_second_old

mutableprivate

Definition at line 514 of file MooseVariableData.h.

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

◆ _need_second_older

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_second_older

mutableprivate

Definition at line 515 of file MooseVariableData.h.

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

◆ _need_second_previous_nl

template<typename OutputType>

bool MooseVariableData< OutputType >::_need_second_previous_nl

mutableprivate

Definition at line 516 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 246 of file MooseVariableDataBase.h.

◆ _need_u_dot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_u_dot_old

mutableprotectedinherited

Definition at line 248 of file MooseVariableDataBase.h.

◆ _need_u_dotdot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_u_dotdot

mutableprotectedinherited

Definition at line 247 of file MooseVariableDataBase.h.

◆ _need_u_dotdot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_u_dotdot_old

mutableprotectedinherited

Definition at line 249 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 219 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 230 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 228 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 494 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 235 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 241 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 280 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 284 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 282 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 286 of file MooseVariableDataBase.h.

◆ _nodal_value_old

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_old

protectedinherited

Definition at line 236 of file MooseVariableDataBase.h.

◆ _nodal_value_old_array

template<typename OutputType>

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_old_array

protectedinherited

Definition at line 242 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 237 of file MooseVariableDataBase.h.

◆ _nodal_value_older_array

template<typename OutputType>

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_older_array

protectedinherited

Definition at line 243 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 238 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 679 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 208 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 211 of file MooseVariableDataBase.h.

◆ _phi

template<typename OutputType>

const FieldVariablePhiValue* MooseVariableData< OutputType >::_phi

private

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

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

◆ _phi_face

template<typename OutputType>

const FieldVariablePhiValue* MooseVariableData< OutputType >::_phi_face

private

Definition at line 610 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 635 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 214 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 593 of file MooseVariableData.h.

◆ _qrule_face

template<typename OutputType>

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

private

Definition at line 594 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 289 of file MooseVariableDataBase.h.

◆ _second_phi

template<typename OutputType>

const FieldVariablePhiSecond* MooseVariableData< OutputType >::_second_phi

mutableprivate

Definition at line 599 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 646 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 612 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 649 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 543 of file MooseVariableData.h.

◆ _second_u_old

template<typename OutputType>

FieldVariableSecond MooseVariableData< OutputType >::_second_u_old

private

Definition at line 544 of file MooseVariableData.h.

◆ _second_u_older

template<typename OutputType>

FieldVariableSecond MooseVariableData< OutputType >::_second_u_older

private

Definition at line 545 of file MooseVariableData.h.

◆ _second_u_previous_nl

template<typename OutputType>

FieldVariableSecond MooseVariableData< OutputType >::_second_u_previous_nl

private

Definition at line 546 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 205 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 292 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 186 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 183 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 189 of file MooseVariableDataBase.h.

◆ _time_integrator

template<typename OutputType>

const TimeIntegrator* MooseVariableData< OutputType >::_time_integrator

private

Pointer to time integrator.

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

◆ _u_dotdot

template<typename OutputType>

FieldVariableValue MooseVariableData< OutputType >::_u_dotdot

private

u_dotdot (second time derivative)

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

◆ _use_dual

template<typename OutputType>

const bool MooseVariableData< OutputType >::_use_dual

private

Definition at line 628 of file MooseVariableData.h.

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

◆ _var_num

template<typename OutputType>

const unsigned int MooseVariableData< OutputType >::_var_num

private

Definition at line 483 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 229 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 227 of file MooseVariableDataBase.h.

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

◆ _vector_tags_dof_u

template<typename OutputType>

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

protectedinherited

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

template<typename OutputType> class MooseVariableData< OutputType >

Member Typedef Documentation

◆ DoFValue

◆ FieldVariableCurl

◆ FieldVariableDivergence

◆ FieldVariableGradient

◆ FieldVariablePhiCurl

◆ FieldVariablePhiDivergence

◆ FieldVariablePhiGradient

◆ FieldVariablePhiSecond

◆ FieldVariablePhiValue

◆ FieldVariableSecond

◆ FieldVariableTestCurl

◆ FieldVariableTestDivergence

◆ FieldVariableTestGradient

◆ FieldVariableTestSecond

◆ FieldVariableTestValue

◆ FieldVariableValue

◆ OutputData

◆ OutputDivergence

◆ OutputGradient

◆ OutputSecond

◆ OutputShape

◆ OutputShapeDivergence

◆ OutputShapeGradient

◆ OutputShapeSecond

Constructor & Destructor Documentation

◆ MooseVariableData()

Member Function Documentation

◆ adCurlSln()

◆ add() [1/2]

◆ add() [2/2]

◆ adDofValues()

◆ adDofValuesDot()

◆ addSolution() [1/2]

◆ addSolution() [2/2]

◆ adGradPhi()

◆ adGradPhiFace()

◆ adGradSln()

◆ adGradSlnDot()

◆ adNodalValue()

◆ adSecondSln()

◆ adSln()

◆ adUDot()

◆ adUDotDot()

◆ arrayGradPhi()

◆ arrayGradPhiFace()

◆ assignADNodalValue() [1/3]

◆ assignADNodalValue() [2/3]

◆ assignADNodalValue() [3/3]

◆ assignNodalValue() [1/3]

◆ assignNodalValue() [2/3]

◆ assignNodalValue() [3/3]

◆ clearDofIndices()

◆ computeAD() [1/2]

◆ computeAD() [2/2]

◆ computeIncrementAtNode() [1/2]

◆ computeIncrementAtNode() [2/2]

◆ computeIncrementAtQps() [1/2]

◆ computeIncrementAtQps() [2/2]

◆ computeMonomialValues()

◆ computeNodalValues()

◆ computeValues()

◆ computeValuesInternal()

◆ computingCurl()

◆ computingDiv()

◆ curlPhi()

◆ curlPhiFace()

◆ curlSln()

◆ currentElem()

◆ currentSide()

◆ divPhi()

◆ divPhiFace()

template<typename OutputType>
class MooseVariableData< OutputType >