#include <MooseVariableConstMonomial.h>

Inheritance diagram for MooseVariableConstMonomial:

Public Member Functions
	MooseVariableConstMonomial (unsigned int var_num, const FEType &fe_type, SystemBase &sys, Assembly &assembly, Moose::VarKindType var_kind, THREAD_ID tid)

virtual void	computeElemValues () override
	Compute values at interior quadrature points. More...

virtual void	computeElemValuesFace () override
	Compute values at facial quadrature points. More...

virtual void	computeNeighborValuesFace () override
	Compute values at facial quadrature points for the neighbor. More...

virtual void	computeNeighborValues () override
	Compute values at quadrature points for the neighbor. More...

virtual void	computeMonomialValuesHelper (const unsigned &nqp, const Real &phi)

virtual void	computeMonomialNeighborValuesHelper (const unsigned &nqp, const Real &phi)

void	clearDofIndices () override
	Clear out the dof indices. More...

void	prepare () override

void	prepareNeighbor () override

void	prepareAux () override

void	reinitNode () override

void	reinitAux () override

void	reinitAuxNeighbor () override

void	reinitNodes (const std::vector< dof_id_type > &nodes) override

void	reinitNodesNeighbor (const std::vector< dof_id_type > &nodes) override

bool	usesPhi ()
	Whether or not this variable is actually using the shape function value. More...

bool	usesGradPhi ()
	Whether or not this variable is actually using the shape function gradient. More...

bool	usesPhiNeighbor ()
	Whether or not this variable is actually using the shape function value. More...

bool	usesGradPhiNeighbor ()
	Whether or not this variable is actually using the shape function gradient. More...

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

bool	usesSecondPhiNeighbor ()
	Whether or not this variable is actually using the shape function second derivative on a neighbor. More...

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

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

const std::set< SubdomainID > &	activeSubdomains () const override
	The subdomains the variable is active on. More...

bool	activeOnSubdomain (SubdomainID subdomain) const override
	Is the variable active on the subdomain? More...

bool	isNodal () const override
	Is this variable nodal. More...

bool	isVector () const override

const Node *&	node () const

virtual dof_id_type &	nodalDofIndex () override

bool	isNodalDefined () const

const Node *&	nodeNeighbor () const

virtual dof_id_type &	nodalDofIndexNeighbor () override

bool	isNodalNeighborDefined () const

const Elem *&	currentElem () const override
	Current element this variable is evaluated at. More...

unsigned int &	currentSide () const
	Current side this variable is being evaluated on. More...

const Elem *&	neighbor () const
	Current neighboring element. More...

const MooseArray< Point > &	normals () const override

virtual void	prepareIC () override
	Prepare the initial condition. More...

const FieldVariablePhiValue &	phi ()

const FieldVariablePhiGradient &	gradPhi ()

const FieldVariablePhiSecond &	secondPhi ()

const FieldVariablePhiCurl &	curlPhi ()

const FieldVariablePhiValue &	phiFace ()

const FieldVariablePhiGradient &	gradPhiFace ()

const FieldVariablePhiSecond &	secondPhiFace ()

const FieldVariablePhiCurl &	curlPhiFace ()

const FieldVariablePhiValue &	phiNeighbor ()

const FieldVariablePhiGradient &	gradPhiNeighbor ()

const FieldVariablePhiSecond &	secondPhiNeighbor ()

const FieldVariablePhiCurl &	curlPhiNeighbor ()

const FieldVariablePhiValue &	phiFaceNeighbor ()

const FieldVariablePhiGradient &	gradPhiFaceNeighbor ()

const FieldVariablePhiSecond &	secondPhiFaceNeighbor ()

const FieldVariablePhiCurl &	curlPhiFaceNeighbor ()

const VariableTestGradientType< Real, compute_stage >::type &	adGradPhi ()

const VariableTestGradientType< Real, compute_stage >::type &	adGradPhiFace ()

FieldVariableValue &	increment ()

const FieldVariableValue &	vectorTagValue (TagID tag)

const FieldVariableValue &	matrixTagValue (TagID tag)

const FieldVariableValue &	sln ()

const FieldVariableValue &	slnOld ()

const FieldVariableValue &	slnOlder ()

const FieldVariableValue &	slnPreviousNL ()

const FieldVariableGradient &	gradSln ()

const FieldVariableGradient &	gradSlnOld ()

const FieldVariableGradient &	gradSlnOlder ()

const FieldVariableGradient &	gradSlnPreviousNL ()

const FieldVariableGradient &	gradSlnDot ()

const FieldVariableGradient &	gradSlnDotDot ()

const FieldVariableSecond &	secondSln ()

const FieldVariableSecond &	secondSlnOld ()

const FieldVariableSecond &	secondSlnOlder ()

const FieldVariableSecond &	secondSlnPreviousNL ()

const FieldVariableCurl &	curlSln ()

const FieldVariableCurl &	curlSlnOld ()

const FieldVariableCurl &	curlSlnOlder ()

const VariableValueType< Real, compute_stage >::type &	adSln ()

const VariableGradientType< Real, compute_stage >::type &	adGradSln ()

const VariableSecondType< Real, compute_stage >::type &	adSecondSln ()

const VariableValueType< Real, compute_stage >::type &	adUDot ()

const VariableValueType< Real, compute_stage >::type &	adSlnNeighbor ()

const VariableGradientType< Real, compute_stage >::type &	adGradSlnNeighbor ()

const VariableSecondType< Real, compute_stage >::type &	adSecondSlnNeighbor ()

const FieldVariableValue &	uDot ()

const FieldVariableValue &	uDotDot ()

const FieldVariableValue &	uDotOld ()

const FieldVariableValue &	uDotDotOld ()

const VariableValue &	duDotDu ()

const VariableValue &	duDotDotDu ()

const VariableValueType< Real, compute_stage >::type &	adUDotNeighbor ()

const FieldVariableValue &	slnNeighbor ()

const FieldVariableValue &	slnOldNeighbor ()

const FieldVariableValue &	slnOlderNeighbor ()

const FieldVariableValue &	slnPreviousNLNeighbor ()

const FieldVariableGradient &	gradSlnNeighbor ()

const FieldVariableGradient &	gradSlnOldNeighbor ()

const FieldVariableGradient &	gradSlnOlderNeighbor ()

const FieldVariableGradient &	gradSlnPreviousNLNeighbor ()

const FieldVariableGradient &	gradSlnNeighborDot ()

const FieldVariableGradient &	gradSlnNeighborDotDot ()

const FieldVariableSecond &	secondSlnNeighbor ()

const FieldVariableSecond &	secondSlnOldNeighbor ()

const FieldVariableSecond &	secondSlnOlderNeighbor ()

const FieldVariableSecond &	secondSlnPreviousNLNeighbor ()

const FieldVariableCurl &	curlSlnNeighbor ()

const FieldVariableCurl &	curlSlnOldNeighbor ()

const FieldVariableCurl &	curlSlnOlderNeighbor ()

const FieldVariableValue &	uDotNeighbor ()

const FieldVariableValue &	uDotDotNeighbor ()

const FieldVariableValue &	uDotOldNeighbor ()

const FieldVariableValue &	uDotDotOldNeighbor ()

const VariableValue &	duDotDuNeighbor ()

const VariableValue &	duDotDotDuNeighbor ()

virtual void	computeValuesHelper (QBase &qrule, const FieldVariablePhiValue &phi, const FieldVariablePhiGradient &grad_phi, const FieldVariablePhiSecond &second_phi, const FieldVariablePhiCurl *&curl_phi, const typename VariableTestGradientType< Real, JACOBIAN >::type &ad_grad_phi)
	Helper function for computing values. More...

virtual void	computeNeighborValuesHelper (QBase &qrule, const FieldVariablePhiValue &phi, const FieldVariablePhiGradient &grad_phi, const FieldVariablePhiSecond &second_phi)
	Helper function for computing values. More...

void	setNodalValue (Real value, unsigned int idx=0)

void	setDofValues (const DenseVector< Number > &value) override
	Set values for this variable to keep everything up to date. More...

Number	getNodalValue (const Node &node) override
	Get the value of this variable at given node. More...

Number	getNodalValueOld (const Node &node) override
	Get the old value of this variable at given node. More...

Number	getNodalValueOlder (const Node &node) override
	Get the t-2 value of this variable at given node. More...

Number	getElementalValue (const Elem *elem, unsigned int idx=0) const override
	Get the current value of this variable on an element. More...

Number	getElementalValueOld (const Elem *elem, unsigned int idx=0) const override
	Get the old value of this variable on an element. More...

Number	getElementalValueOlder (const Elem *elem, unsigned int idx=0) const override
	Get the older value of this variable on an element. More...

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

std::vector< dof_id_type > &	dofIndicesNeighbor () override
	Get neighbor DOF indices for currently selected element. More...

unsigned int	numberOfDofsNeighbor () override

void	insert (NumericVector< Number > &residual) override

void	add (NumericVector< Number > &residual) override

const MooseArray< Number > &	dofValue () override
	Deprecated method. More...

const MooseArray< Number > &	dofValues () override
	Returns dof solution on element. More...

const MooseArray< Number > &	dofValuesOld () override
	Returns old dof solution on element. More...

const MooseArray< Number > &	dofValuesOlder () override
	Returns older dof solution on element. More...

const MooseArray< Number > &	dofValuesPreviousNL () override
	Returns previous nl solution on element. More...

const MooseArray< Number > &	dofValuesNeighbor () override
	Returns dof solution on neighbor element. More...

const MooseArray< Number > &	dofValuesOldNeighbor () override
	Returns old dof solution on neighbor element. More...

const MooseArray< Number > &	dofValuesOlderNeighbor () override
	Returns older dof solution on neighbor element. More...

const MooseArray< Number > &	dofValuesPreviousNLNeighbor () override
	Returns previous nl solution on neighbor element. More...

const MooseArray< Number > &	dofValuesDot () override
	Returns time derivative of degrees of freedom. More...

const MooseArray< Number > &	dofValuesDotNeighbor () override
	Returns time derivative of neighboring degrees of freedom. More...

const MooseArray< Number > &	dofValuesDotOld () override
	Returns old time derivative of degrees of freedom. More...

const MooseArray< Number > &	dofValuesDotOldNeighbor () override
	Returns old time derivative of neighboring degrees of freedom. More...

const MooseArray< Number > &	dofValuesDotDot () override
	Returns second time derivative of degrees of freedom. More...

const MooseArray< Number > &	dofValuesDotDotNeighbor () override
	Returns second time derivative of neighboring degrees of freedom. More...

const MooseArray< Number > &	dofValuesDotDotOld () override
	Returns old second time derivative of degrees of freedom. More...

const MooseArray< Number > &	dofValuesDotDotOldNeighbor () override
	Returns old second time derivative of neighboring degrees of freedom. More...

const MooseArray< Number > &	dofValuesDuDotDu () override
	Returns derivative of time derivative of degrees of freedom. More...

const MooseArray< Number > &	dofValuesDuDotDuNeighbor () override
	Returns derivative of time derivative of neighboring degrees of freedom. More...

const MooseArray< Number > &	dofValuesDuDotDotDu () override
	Returns derivative of second time derivative of degrees of freedom. More...

const MooseArray< Number > &	dofValuesDuDotDotDuNeighbor () override
	Returns derivative of second time derivative of neighboring degrees of freedom. More...

const MooseArray< typename Moose::RealType< compute_stage >::type > &	adDofValues ()
	Return the AD dof values. More...

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

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

Real	getValue (const Elem *elem, const std::vector< std::vector< Real >> &phi) const
	Compute the variable value at a point on an element. More...

OutputTools< Real >::OutputGradient	getGradient (const Elem *elem, const std::vector< std::vector< typename OutputTools< Real >::OutputGradient >> &grad_phi) const
	Compute the variable gradient value at a point on an element. More...

virtual size_t	phiSize () override
	Return phi size. More...

virtual size_t	phiFaceSize () override
	Return phiFace size. More...

virtual size_t	phiNeighborSize () override
	Return phiNeighbor size. More...

virtual size_t	phiFaceNeighborSize () override
	Return phiFaceNeighbor size. More...

const Real &	nodalValue ()
	Methods for retrieving values of variables at the nodes. More...

const Real &	nodalValueOld ()

const Real &	nodalValueOlder ()

const Real &	nodalValuePreviousNL ()

const Real &	nodalValueDot ()

const Real &	nodalValueDotDot ()

const Real &	nodalValueDotOld ()

const Real &	nodalValueDotDotOld ()

const Real &	nodalValueDuDotDu ()

const Real &	nodalValueDuDotDotDu ()

const Real &	nodalValueNeighbor ()

const Real &	nodalValueOldNeighbor ()

const Real &	nodalValueOlderNeighbor ()

const Real &	nodalValuePreviousNLNeighbor ()

const Real &	nodalValueDotNeighbor ()

const Real &	nodalValueDotDotNeighbor ()

const Real &	nodalValueDotOldNeighbor ()

const Real &	nodalValueDotDotOldNeighbor ()

const Real &	nodalValueDuDotDuNeighbor ()

const Real &	nodalValueDuDotDotDuNeighbor ()

const MooseArray< Real > &	nodalValueArray ()
	Methods for retrieving values of variables at the nodes in a MooseArray for AuxKernelBase. More...

const MooseArray< Real > &	nodalValueOldArray ()

const MooseArray< Real > &	nodalValueOlderArray ()

const MooseArray< Real > &	nodalVectorTagValue (TagID tag)

const MooseArray< Real > &	nodalMatrixTagValue (TagID tag)

const Moose::ValueType< Real, compute_stage >::type &	adNodalValue ()

virtual void	computeNodalValues () override
	Compute nodal values of this variable. More...

virtual void	computeNodalNeighborValues () override
	Compute nodal values of this variable in the neighbor. More...

void	computeAD (const unsigned int num_dofs, const unsigned int nqp, const bool is_transient, const FieldVariablePhiValue &phi, const FieldVariablePhiGradient &grad_phi, const FieldVariablePhiSecond *&second_phi, const typename VariableTestGradientType< Real, JACOBIAN >::type &ad_grad_phi)

void	computeADNeighbor (const unsigned int num_dofs, const unsigned int nqp, const bool is_transient, const FieldVariablePhiValue &phi, const FieldVariablePhiGradient &grad_phi, const FieldVariablePhiSecond *&second_phi)

void	assignADNodalValue (const DualReal &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	assignNodalValue ()

void	fetchDoFValues ()

void	fetchADDoFValues ()

void	zeroSizeDofValues ()

void	assignNodalValueNeighbor ()

void	fetchDoFValuesNeighbor ()

void	zeroSizeDofValuesNeighbor ()

unsigned int	number () const
	Get variable number coming from libMesh. More...

const FEType &	feType () const
	Get the type of finite element object. More...

SystemBase &	sys ()
	Get the system this variable is part of. More...

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

const std::vector< dof_id_type > &	allDofIndices () const
	Get all global dofindices for the variable. More...

unsigned int	totalVarDofs ()

Moose::VarKindType	kind () const
	Kind of the variable (Nonlinear, Auxiliary, ...) More...

void	scalingFactor (Real factor)
	Set the scaling factor for this variable. More...

Real	scalingFactor () const
	Get the scaling factor for this variable. More...

Order	order () const
	Get the order of this variable Note: Order enum can be implicitly converted to unsigned int. More...

const DofMap &	dofMap () const
	The DofMap associated with the system this variable is in. More...

std::vector< dof_id_type > &	dofIndices ()
	Get a writable reference of local DoF indices. More...

const std::vector< dof_id_type > &	dofIndices () const
	Get local DoF indices. More...

unsigned int	numberOfDofs ()
	Get the number of local DoFs. More...

Protected Attributes
const bool	_displaced
	Whether this variable is on the displaced system. More...

Assembly &	_assembly
	Our assembly. More...

QBase *&	_qrule
	Quadrature rule for interior. More...

QBase *&	_qrule_face
	Quadrature rule for the face. More...

QBase *&	_qrule_neighbor
	Quadrature rule for the neighbor. More...

const Elem *&	_elem
	current element More...

unsigned int &	_current_side
	the side of the current element (valid when doing face assembly) More...

const Elem *&	_neighbor
	neighboring element More...

std::vector< dof_id_type >	_dof_indices_neighbor
	DOF indices (neighbor) More...

bool	_need_u_old

bool	_need_u_older

bool	_need_u_previous_nl

bool	_need_u_dot

bool	_need_ad_u_dot

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_old

bool	_need_grad_older

bool	_need_grad_previous_nl

bool	_need_grad_dot

bool	_need_grad_dotdot

bool	_need_second

bool	_need_second_old

bool	_need_second_older

bool	_need_second_previous_nl

bool	_need_curl

bool	_need_curl_old

bool	_need_curl_older

bool	_need_ad

bool	_need_ad_u

bool	_need_ad_grad_u

bool	_need_ad_second_u

bool	_need_neighbor_ad

bool	_need_neighbor_ad_u

bool	_need_neighbor_ad_grad_u

bool	_need_neighbor_ad_second_u

bool	_need_u_old_neighbor

bool	_need_u_older_neighbor

bool	_need_u_previous_nl_neighbor

bool	_need_u_dot_neighbor

bool	_need_neighbor_ad_u_dot

bool	_need_u_dotdot_neighbor

bool	_need_u_dot_old_neighbor

bool	_need_u_dotdot_old_neighbor

bool	_need_du_dot_du_neighbor

bool	_need_du_dotdot_du_neighbor

bool	_need_grad_old_neighbor

bool	_need_grad_older_neighbor

bool	_need_grad_previous_nl_neighbor

bool	_need_grad_neighbor_dot

bool	_need_grad_neighbor_dotdot

bool	_need_second_neighbor

bool	_need_second_old_neighbor

bool	_need_second_older_neighbor

bool	_need_second_previous_nl_neighbor

bool	_need_curl_neighbor

bool	_need_curl_old_neighbor

bool	_need_curl_older_neighbor

bool	_need_dof_values

bool	_need_dof_values_old

bool	_need_dof_values_older

bool	_need_dof_values_previous_nl

bool	_need_dof_values_dot

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

bool	_need_dof_values_neighbor

bool	_need_dof_values_old_neighbor

bool	_need_dof_values_older_neighbor

bool	_need_dof_values_previous_nl_neighbor

bool	_need_dof_values_dot_neighbor

bool	_need_dof_values_dotdot_neighbor

bool	_need_dof_values_dot_old_neighbor

bool	_need_dof_values_dotdot_old_neighbor

bool	_need_dof_du_dot_du_neighbor

bool	_need_dof_du_dotdot_du_neighbor

std::vector< bool >	_need_vector_tag_dof_u

std::vector< bool >	_need_matrix_tag_dof_u

const MooseArray< Point > &	_normals
	Normals at QPs on faces. More...

bool	_is_nodal
	if variable is nodal More...

bool	_has_dof_indices
	If we have dofs. More...

bool	_neighbor_has_dof_indices
	If the neighor has dofs. More...

bool	_has_dof_values
	If true, the dof values get inserted on calling insert() More...

bool	_has_dof_values_neighbor

const Node *&	_node

const Node *&	_node_neighbor

dof_id_type	_nodal_dof_index

dof_id_type	_nodal_dof_index_neighbor

MooseArray< Real >	_dof_values

MooseArray< Real >	_dof_values_old

MooseArray< Real >	_dof_values_older

MooseArray< Real >	_dof_values_previous_nl

std::vector< MooseArray< Real > >	_vector_tags_dof_u

std::vector< MooseArray< Real > >	_matrix_tags_dof_u

MooseArray< Real >	_dof_values_dot
	nodal values of u_dot More...

MooseArray< Real >	_dof_values_dotdot
	nodal values of u_dotdot More...

MooseArray< Real >	_dof_values_dot_old
	nodal values of u_dot_old More...

MooseArray< Real >	_dof_values_dotdot_old
	nodal values of u_dotdot_old More...

MooseArray< Real >	_dof_du_dot_du
	nodal values of derivative of u_dot wrt u More...

MooseArray< Real >	_dof_du_dotdot_du
	nodal values of derivative of u_dotdot wrt u More...

MooseArray< Real >	_dof_values_neighbor

MooseArray< Real >	_dof_values_old_neighbor

MooseArray< Real >	_dof_values_older_neighbor

MooseArray< Real >	_dof_values_previous_nl_neighbor

MooseArray< Real >	_dof_values_dot_neighbor

MooseArray< Real >	_dof_values_dotdot_neighbor

MooseArray< Real >	_dof_values_dot_old_neighbor

MooseArray< Real >	_dof_values_dotdot_old_neighbor

MooseArray< Real >	_dof_du_dot_du_neighbor

MooseArray< Real >	_dof_du_dotdot_du_neighbor

const FieldVariablePhiValue &	_phi

const FieldVariablePhiGradient &	_grad_phi

const FieldVariablePhiSecond *	_second_phi

const FieldVariablePhiCurl *	_curl_phi

const FieldVariablePhiValue &	_phi_face

const FieldVariablePhiGradient &	_grad_phi_face

const FieldVariablePhiSecond *	_second_phi_face

const FieldVariablePhiCurl *	_curl_phi_face

const FieldVariablePhiValue &	_phi_neighbor

const FieldVariablePhiGradient &	_grad_phi_neighbor

const FieldVariablePhiSecond *	_second_phi_neighbor

const FieldVariablePhiCurl *	_curl_phi_neighbor

const FieldVariablePhiValue &	_phi_face_neighbor

const FieldVariablePhiGradient &	_grad_phi_face_neighbor

const FieldVariablePhiSecond *	_second_phi_face_neighbor

const FieldVariablePhiCurl *	_curl_phi_face_neighbor

const VariableTestGradientType< OutputShape, JACOBIAN >::type &	_ad_grad_phi

const VariableTestGradientType< OutputShape, JACOBIAN >::type &	_ad_grad_phi_face

std::vector< FieldVariableValue >	_vector_tag_u

std::vector< bool >	_need_vector_tag_u

std::vector< FieldVariableValue >	_matrix_tag_u

std::vector< bool >	_need_matrix_tag_u

FieldVariableValue	_u

FieldVariableValue	_u_old

FieldVariableValue	_u_older

FieldVariableValue	_u_previous_nl

FieldVariableGradient	_grad_u

FieldVariableGradient	_grad_u_old

FieldVariableGradient	_grad_u_older

FieldVariableGradient	_grad_u_previous_nl

FieldVariableGradient	_grad_u_dot

FieldVariableGradient	_grad_u_dotdot

FieldVariableSecond	_second_u

FieldVariableSecond	_second_u_old

FieldVariableSecond	_second_u_older

FieldVariableSecond	_second_u_previous_nl

FieldVariableCurl	_curl_u

FieldVariableCurl	_curl_u_old

FieldVariableCurl	_curl_u_older

VariableValueType< OutputShape, JACOBIAN >::type	_ad_u

VariableGradientType< OutputShape, JACOBIAN >::type	_ad_grad_u

VariableSecondType< OutputShape, JACOBIAN >::type	_ad_second_u

MooseArray< DualReal >	_ad_dof_values

MooseArray< DualReal >	_ad_dofs_dot

VariableValueType< OutputShape, JACOBIAN >::type	_ad_u_dot

VariableValueType< OutputShape, JACOBIAN >::type	_neighbor_ad_u

VariableGradientType< OutputShape, JACOBIAN >::type	_neighbor_ad_grad_u

VariableSecondType< OutputShape, JACOBIAN >::type	_neighbor_ad_second_u

MooseArray< DualReal >	_neighbor_ad_dof_values

MooseArray< DualReal >	_neighbor_ad_dofs_dot

VariableValueType< OutputShape, JACOBIAN >::type	_neighbor_ad_u_dot

FieldVariableValue	_u_neighbor

FieldVariableValue	_u_old_neighbor

FieldVariableValue	_u_older_neighbor

FieldVariableValue	_u_previous_nl_neighbor

FieldVariableGradient	_grad_u_neighbor

FieldVariableGradient	_grad_u_old_neighbor

FieldVariableGradient	_grad_u_older_neighbor

FieldVariableGradient	_grad_u_previous_nl_neighbor

FieldVariableGradient	_grad_u_neighbor_dot

FieldVariableGradient	_grad_u_neighbor_dotdot

FieldVariableSecond	_second_u_neighbor

FieldVariableSecond	_second_u_old_neighbor

FieldVariableSecond	_second_u_older_neighbor

FieldVariableSecond	_second_u_previous_nl_neighbor

FieldVariableCurl	_curl_u_neighbor

FieldVariableCurl	_curl_u_old_neighbor

FieldVariableCurl	_curl_u_older_neighbor

FieldVariableValue	_u_dot
	u_dot (time derivative) More...

FieldVariableValue	_u_dot_neighbor

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

FieldVariableValue	_u_dotdot_bak

FieldVariableValue	_u_dotdot_neighbor

FieldVariableValue	_u_dotdot_bak_neighbor

FieldVariableValue	_u_dot_old
	u_dot_old (time derivative) More...

FieldVariableValue	_u_dot_old_bak

FieldVariableValue	_u_dot_old_neighbor

FieldVariableValue	_u_dot_old_bak_neighbor

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

FieldVariableValue	_u_dotdot_old_bak

FieldVariableValue	_u_dotdot_old_neighbor

FieldVariableValue	_u_dotdot_old_bak_neighbor

VariableValue	_du_dot_du
	derivative of u_dot wrt u More...

VariableValue	_du_dot_du_neighbor

VariableValue	_du_dotdot_du
	derivative of u_dotdot wrt u More...

VariableValue	_du_dotdot_du_bak

VariableValue	_du_dotdot_du_neighbor

VariableValue	_du_dotdot_du_bak_neighbor

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

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

Real	_nodal_value
	Nodal values. More...

Real	_nodal_value_old

Real	_nodal_value_older

Real	_nodal_value_previous_nl

Real	_neighbor_nodal_value

Real	_neighbor_nodal_value_old

Real	_neighbor_nodal_value_older

Real	_neighbor_nodal_value_previous_nl

Real	_nodal_value_dot
	nodal values of u_dot More...

Real	_nodal_value_dotdot
	nodal values of u_dotdot More...

Real	_nodal_value_dot_old
	nodal values of u_dot_old More...

Real	_nodal_value_dotdot_old
	nodal values of u_dotdot_old More...

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

MooseArray< Real >	_nodal_value_old_array

MooseArray< Real >	_nodal_value_older_array

Moose::ValueType< Real, JACOBIAN >::type	_ad_nodal_value
	AD nodal value. More...

const DualReal	_ad_zero
	A zero AD variable. More...

TimeIntegrator *	_time_integrator
	A pointer to TimeIntegrator. nullptr if _sys is not a NonlinearSystemBase. More...

unsigned int	_var_num
	variable number (from libMesh) More...

FEType	_fe_type
	The FEType associated with this variable. More...

unsigned int	_index
	variable number within MOOSE More...

Moose::VarKindType	_var_kind

SubProblem &	_subproblem
	Problem this variable is part of. More...

SystemBase &	_sys
	System this variable is part of. More...

const Variable &	_variable
	libMesh variable object for this variable More...

const DofMap &	_dof_map
	DOF map. More...

std::vector< dof_id_type >	_dof_indices
	DOF indices. More...

MooseMesh &	_mesh
	mesh the variable is active in More...

Real	_scaling_factor
	scaling factor for this variable More...

THREAD_ID	_tid
	Thread ID. More...

Detailed Description

Definition at line 18 of file MooseVariableConstMonomial.h.

Constructor & Destructor Documentation

◆ MooseVariableConstMonomial()

MooseVariableConstMonomial::MooseVariableConstMonomial	(	unsigned int	var_num,
		const FEType &	fe_type,
		SystemBase &	sys,
		Assembly &	assembly,
		Moose::VarKindType	var_kind,
		THREAD_ID	tid
	)

Definition at line 17 of file MooseVariableConstMonomial.C.

   : MooseVariable(var_num, fe_type, sys, assembly, var_kind, tid)
 {
 }

Member Function Documentation

◆ activeOnSubdomain()

bool MooseVariableFE< Real >::activeOnSubdomain ( SubdomainID subdomain ) const

overridevirtualinherited

Is the variable active on the subdomain?

Parameters

subdomain The subdomain id in question

Returns: true if active on subdomain, false otherwise

Implements MooseVariableFEBase.

Definition at line 312 of file MooseVariableFE.C.

 {
   return _sys.system().variable(_var_num).active_on_subdomain(subdomain);
 }

◆ activeSubdomains()

const std::set< SubdomainID > & MooseVariableFE< Real >::activeSubdomains ( ) const

overridevirtualinherited

The subdomains the variable is active on.

Implements MooseVariableFEBase.

Definition at line 305 of file MooseVariableFE.C.

 {
   return _sys.system().variable(_var_num).active_subdomains();
 }

◆ add()

void MooseVariableFE< Real >::add ( NumericVector< Number > & residual )

overridevirtualinherited

Implements MooseVariableFEBase.

Definition at line 574 of file MooseVariableFE.C.

 {
   if (_has_dof_values)
     residual.add_vector(&_dof_values[0], _dof_indices);
 }

◆ adDofValues()

const MooseArray< typename Moose::RealType< compute_stage >::type > & MooseVariableFE< Real >::adDofValues ( )

inherited

Return the AD dof values.

Definition at line 2490 of file MooseVariableFE.C.

 {
   _need_ad = true;
   return _ad_dof_values;
 }

◆ adGradPhi()

const VariableTestGradientType<Real , compute_stage>::type& MooseVariableFE< Real >::adGradPhi ( )

inlineinherited

Definition at line 185 of file MooseVariableFE.h.

   {
     return _ad_grad_phi;
   }

◆ adGradPhiFace()

const VariableTestGradientType<Real , compute_stage>::type& MooseVariableFE< Real >::adGradPhiFace ( )

inlineinherited

Definition at line 191 of file MooseVariableFE.h.

   {
     return _ad_grad_phi_face;
   }

◆ adGradSln()

const VariableGradientType<Real , compute_stage>::type& MooseVariableFE< Real >::adGradSln ( )

inlineinherited

Definition at line 322 of file MooseVariableFE.h.

   {
     _need_ad = _need_ad_grad_u = true;
     return _ad_grad_u;
   }

◆ adGradSlnNeighbor()

const VariableGradientType<Real , compute_stage>::type& MooseVariableFE< Real >::adGradSlnNeighbor ( )

inlineinherited

Definition at line 352 of file MooseVariableFE.h.

   {
     _need_neighbor_ad = _need_neighbor_ad_grad_u = true;
     return _neighbor_ad_grad_u;
   }

◆ adNodalValue()

const Moose::ValueType< Real , compute_stage >::type & MooseVariableFE< Real >::adNodalValue ( )

inherited

Definition at line 2515 of file MooseVariableFE.C.

 {
   _need_ad = true;
   return _ad_nodal_value;
 }

◆ adSecondSln()

const VariableSecondType<Real , compute_stage>::type& MooseVariableFE< Real >::adSecondSln ( )

inlineinherited

Definition at line 329 of file MooseVariableFE.h.

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

◆ adSecondSlnNeighbor()

const VariableSecondType<Real , compute_stage>::type& MooseVariableFE< Real >::adSecondSlnNeighbor ( )

inlineinherited

Definition at line 359 of file MooseVariableFE.h.

   {
     _need_neighbor_ad = _need_neighbor_ad_second_u = true;
     secondPhiFaceNeighbor();
     return _neighbor_ad_second_u;
   }

◆ adSln()

const VariableValueType<Real , compute_stage>::type& MooseVariableFE< Real >::adSln ( )

inlineinherited

Definition at line 315 of file MooseVariableFE.h.

   {
     _need_ad = _need_ad_u = true;
     return _ad_u;
   }

◆ adSlnNeighbor()

const VariableValueType<Real , compute_stage>::type& MooseVariableFE< Real >::adSlnNeighbor ( )

inlineinherited

Definition at line 345 of file MooseVariableFE.h.

   {
     _need_neighbor_ad = _need_neighbor_ad_u = true;
     return _neighbor_ad_u;
   }

◆ adUDot()

const VariableValueType<Real , compute_stage>::type& MooseVariableFE< Real >::adUDot ( )

inlineinherited

Definition at line 338 of file MooseVariableFE.h.

   {
     _need_ad = _need_ad_u_dot = true;
     return _ad_u_dot;
   }

◆ adUDotNeighbor()

const VariableValueType<Real , compute_stage>::type& MooseVariableFE< Real >::adUDotNeighbor ( )

inlineinherited

Definition at line 430 of file MooseVariableFE.h.

   {
     _need_neighbor_ad = _need_neighbor_ad_u_dot = true;
     return _neighbor_ad_u_dot;
   }

◆ allDofIndices()

const std::vector< dof_id_type > & MooseVariableBase::allDofIndices ( ) const

inherited

Get all global dofindices for the variable.

Definition at line 46 of file MooseVariableBase.C.

Referenced by FEProblemBase::addJacobianBlock(), NonlocalIntegratedBC::computeNonlocalJacobian(), NonlocalKernel::computeNonlocalJacobian(), NonlocalIntegratedBC::computeNonlocalOffDiagJacobian(), NonlocalKernel::computeNonlocalOffDiagJacobian(), FEProblemBase::prepare(), Assembly::prepareNonlocal(), Assembly::prepareVariableNonlocal(), and MooseVariableBase::totalVarDofs().

 {
   const auto it = _sys.subproblem()._var_dof_map.find(name());
   if (it != _sys.subproblem()._var_dof_map.end())
     return it->second;
   else
     mooseError("VariableAllDoFMap not prepared for ",
                name(),
                " . Check nonlocal coupling requirement for the variable.");
 }

◆ assignADNodalValue()

void MooseVariableFE< Real >::assignADNodalValue	(	const DualReal &	value,
		const unsigned int &	component
	)

inherited

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

◆ assignNodalValue()

void MooseVariableFE< Real >::assignNodalValue ( )

inherited

Definition at line 2064 of file MooseVariableFE.C.

 {
   bool is_transient = _subproblem.isTransient();
 
   libmesh_assert(_dof_indices.size());
 
   _nodal_value = _dof_values[0];
   _nodal_value_array[0] = _nodal_value;
 
   if (is_transient)
   {
     if (_need_dof_values_old)
     {
       _nodal_value_old = _dof_values_old[0];
       _nodal_value_old_array[0] = _nodal_value_old;
     }
     if (_need_dof_values_older)
     {
       _nodal_value_older = _dof_values_older[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 (_need_dof_values_previous_nl)
     _nodal_value_previous_nl = _dof_values_previous_nl[0];
 }

◆ assignNodalValueNeighbor()

void MooseVariableFE< Real >::assignNodalValueNeighbor ( )

inherited

Definition at line 2229 of file MooseVariableFE.C.

 {
   bool is_transient = _subproblem.isTransient();
 
   libmesh_assert(_dof_indices_neighbor.size());
 
   _neighbor_nodal_value = _dof_values_neighbor[0];
 
   if (_need_dof_values_previous_nl_neighbor)
     _neighbor_nodal_value_previous_nl = _dof_values_previous_nl_neighbor[0];
 
   if (is_transient)
   {
     if (_need_dof_values_old_neighbor)
       _neighbor_nodal_value_old = _dof_values_old_neighbor[0];
     if (_need_dof_values_older_neighbor)
       _neighbor_nodal_value_older = _dof_values_older_neighbor[0];
   }
 }

◆ clearDofIndices()

void MooseVariableFE< Real >::clearDofIndices ( )

overridevirtualinherited

Clear out the dof indices.

We do this in case this variable is not going to be prepared at all...

Implements MooseVariableFEBase.

Definition at line 319 of file MooseVariableFE.C.

 {
   _dof_indices.clear();
 }

◆ computeAD()

void MooseVariableFE< Real >::computeAD	(	const unsigned int	num_dofs,
		const unsigned int	nqp,
		const bool	is_transient,
		const FieldVariablePhiValue &	phi,
		const FieldVariablePhiGradient &	grad_phi,
		const FieldVariablePhiSecond *&	second_phi,
		const typename VariableTestGradientType< Real , JACOBIAN >::type &	ad_grad_phi
	)

inherited

Definition at line 1184 of file MooseVariableFE.C.

 {
   _ad_dof_values.resize(num_dofs);
   if (_need_ad_u)
     _ad_u.resize(nqp);
 
   if (_need_ad_grad_u)
     _ad_grad_u.resize(nqp);
 
   if (_need_ad_second_u)
     _ad_second_u.resize(nqp);
 
   if (_need_ad_u_dot)
   {
     _ad_dofs_dot.resize(num_dofs);
     _ad_u_dot.resize(nqp);
   }
 
   // Derivatives are offset by the variable number
   size_t ad_offset = _var_num * _sys.getMaxVarNDofsPerElem();
 
   // Hopefully this problem can go away at some point
   if (ad_offset + num_dofs > AD_MAX_DOFS_PER_ELEM)
     mooseError("Current number of dofs per element is greater than AD_MAX_DOFS_PER_ELEM of ",
                AD_MAX_DOFS_PER_ELEM);
 
   for (unsigned int qp = 0; qp < nqp; qp++)
   {
     if (_need_ad_u)
       _ad_u[qp] = _ad_zero;
 
     if (_need_ad_grad_u)
       _ad_grad_u[qp] = _ad_zero;
 
     if (_need_ad_second_u)
       _ad_second_u[qp] = _ad_zero;
 
     if (_need_ad_u_dot)
       _ad_u_dot[qp] = _ad_zero;
   }
 
   for (unsigned int i = 0; i < num_dofs; i++)
   {
     _ad_dof_values[i] = (*_sys.currentSolution())(_dof_indices[i]);
 
     // NOTE!  You have to do this AFTER setting the value!
     if (_var_kind == Moose::VAR_NONLINEAR)
       _ad_dof_values[i].derivatives()[ad_offset + i] = 1.0;
 
     if (_need_ad_u_dot && _time_integrator)
     {
       _ad_dofs_dot[i] = _ad_dof_values[i];
       _time_integrator->computeADTimeDerivatives(_ad_dofs_dot[i], _dof_indices[i]);
     }
   }
 
   // Now build up the solution at each quadrature point:
   for (unsigned int i = 0; i < num_dofs; i++)
   {
     for (unsigned int qp = 0; qp < nqp; qp++)
     {
       if (_need_ad_u)
         _ad_u[qp] += _ad_dof_values[i] * phi[i][qp];
 
       if (_need_ad_grad_u)
       {
         if (_displaced)
           _ad_grad_u[qp] += _ad_dof_values[i] * ad_grad_phi[i][qp];
         else
           _ad_grad_u[qp] += _ad_dof_values[i] * grad_phi[i][qp];
       }
 
       if (_need_ad_second_u)
       {
         if (_displaced)
           mooseError("Support for second order shape function derivatives on the displaced mesh "
                      "has not been added yet!");
         else
           _ad_second_u[qp] += _ad_dof_values[i] * (*second_phi)[i][qp];
       }
 
       if (_need_ad_u_dot && _time_integrator)
         _ad_u_dot[qp] += phi[i][qp] * _ad_dofs_dot[i];
     }
   }
 
   if (_need_ad_u_dot && !_time_integrator)
     for (MooseIndex(nqp) qp = 0; qp < nqp; ++qp)
       _ad_u_dot[qp] = _u_dot[qp];
 }

◆ computeADNeighbor()

void MooseVariableFE< Real >::computeADNeighbor	(	const unsigned int	num_dofs,
		const unsigned int	nqp,
		const bool	is_transient,
		const FieldVariablePhiValue &	phi,
		const FieldVariablePhiGradient &	grad_phi,
		const FieldVariablePhiSecond *&	second_phi
	)

inherited

Definition at line 1284 of file MooseVariableFE.C.

 {
   _neighbor_ad_dof_values.resize(num_dofs);
   if (_need_neighbor_ad_u)
     _neighbor_ad_u.resize(nqp);
 
   if (_need_neighbor_ad_grad_u)
     _neighbor_ad_grad_u.resize(nqp);
 
   if (_need_neighbor_ad_second_u)
     _neighbor_ad_second_u.resize(nqp);
 
   if (_need_neighbor_ad_u_dot)
     _neighbor_ad_u_dot.resize(nqp);
 
   // Derivatives are offset by the variable number
   size_t ad_offset = _var_num * _sys.getMaxVarNDofsPerElem() +
                      (_sys.system().n_vars() * _sys.getMaxVarNDofsPerElem());
 
   // Hopefully this problem can go away at some point
   if (ad_offset + num_dofs > AD_MAX_DOFS_PER_ELEM)
     mooseError("Current number of dofs per element is greater than AD_MAX_DOFS_PER_ELEM of ",
                AD_MAX_DOFS_PER_ELEM);
 
   for (unsigned int qp = 0; qp < nqp; qp++)
   {
     if (_need_neighbor_ad_u)
       _neighbor_ad_u[qp] = _ad_zero;
 
     if (_need_neighbor_ad_grad_u)
       _neighbor_ad_grad_u[qp] = _ad_zero;
 
     if (_need_neighbor_ad_second_u)
       _neighbor_ad_second_u[qp] = _ad_zero;
 
     if (_need_neighbor_ad_u_dot)
       _neighbor_ad_u_dot[qp] = _ad_zero;
   }
 
   for (unsigned int i = 0; i < num_dofs; i++)
   {
     _neighbor_ad_dof_values[i] = (*_sys.currentSolution())(_dof_indices_neighbor[i]);
 
     // NOTE!  You have to do this AFTER setting the value!
     if (_var_kind == Moose::VAR_NONLINEAR)
       _neighbor_ad_dof_values[i].derivatives()[ad_offset + i] = 1.0;
 
     if (_need_neighbor_ad_u_dot && _time_integrator)
     {
       _neighbor_ad_dofs_dot[i] = _neighbor_ad_dof_values[i];
       _time_integrator->computeADTimeDerivatives(_neighbor_ad_dofs_dot[i],
                                                  _dof_indices_neighbor[i]);
     }
   }
 
   // Now build up the solution at each quadrature point:
   for (unsigned int i = 0; i < num_dofs; i++)
   {
     for (unsigned int qp = 0; qp < nqp; qp++)
     {
       if (_need_neighbor_ad_u)
         _neighbor_ad_u[qp] += _neighbor_ad_dof_values[i] * phi[i][qp];
 
       if (_need_neighbor_ad_grad_u)
         _neighbor_ad_grad_u[qp] += _neighbor_ad_dof_values[i] * grad_phi[i][qp];
 
       if (_need_neighbor_ad_second_u)
         _neighbor_ad_second_u[qp] += _neighbor_ad_dof_values[i] * (*second_phi)[i][qp];
 
       if (_need_neighbor_ad_u_dot && _time_integrator)
         _neighbor_ad_u_dot[qp] += phi[i][qp] * _neighbor_ad_dofs_dot[i];
     }
   }
 
   if (_need_neighbor_ad_u_dot && !_time_integrator)
     for (MooseIndex(nqp) qp = 0; qp < nqp; ++qp)
       _neighbor_ad_u_dot[qp] = _u_dot_neighbor[qp];
 }

◆ computeElemValues()

void MooseVariableConstMonomial::computeElemValues ( )

overridevirtual

Compute values at interior quadrature points.

Reimplemented from MooseVariableFE< Real >.

Definition at line 411 of file MooseVariableConstMonomial.C.

 {
   if (_dof_indices.size() == 0)
     return;
 
   computeMonomialValuesHelper(_qrule->n_points(), _phi[0][0]);
 }

◆ computeElemValuesFace()

void MooseVariableConstMonomial::computeElemValuesFace ( )

overridevirtual

Compute values at facial quadrature points.

Reimplemented from MooseVariableFE< Real >.

Definition at line 420 of file MooseVariableConstMonomial.C.

 {
   if (_dof_indices.size() == 0)
     return;
 
   computeMonomialValuesHelper(_qrule_face->n_points(), _phi_face[0][0]);
 }

◆ computeIncrementAtNode()

void MooseVariableFE< Real >::computeIncrementAtNode ( const NumericVector< Number > & increment_vec )

inherited

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

Definition at line 863 of file MooseVariableFE.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]);
 }

◆ computeIncrementAtQps()

void MooseVariableFE< Real >::computeIncrementAtQps ( const NumericVector< Number > & increment_vec )

inherited

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

Definition at line 846 of file MooseVariableFE.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 (unsigned int qp = 0; qp < nqp; qp++)
   {
     _increment[qp] = 0;
     for (unsigned int i = 0; i < num_dofs; i++)
       _increment[qp] += _phi[i][qp] * increment_vec(_dof_indices[i]);
   }
 }

◆ computeMonomialNeighborValuesHelper()

void MooseVariableConstMonomial::computeMonomialNeighborValuesHelper	(	const unsigned &	nqp,
		const Real &	phi
	)

virtual

Definition at line 229 of file MooseVariableConstMonomial.C.

Referenced by computeNeighborValues(), and computeNeighborValuesFace().

 {
   bool is_transient = _subproblem.isTransient();
 
   _u_neighbor.resize(nqp);
   _grad_u_neighbor.resize(nqp);
 
   if (_need_second_neighbor)
     _second_u_neighbor.resize(nqp);
 
   if (is_transient)
   {
     if (_need_u_dot_neighbor)
       _u_dot_neighbor.resize(nqp);
 
     if (_need_u_dotdot_neighbor)
       _u_dotdot_neighbor.resize(nqp);
 
     if (_need_u_dot_old_neighbor)
       _u_dot_old_neighbor.resize(nqp);
 
     if (_need_u_dotdot_old_neighbor)
       _u_dotdot_old_neighbor.resize(nqp);
 
     if (_need_du_dot_du_neighbor)
       _du_dot_du_neighbor.resize(nqp);
 
     if (_need_du_dotdot_du_neighbor)
       _du_dotdot_du_neighbor.resize(nqp);
 
     if (_need_u_old_neighbor)
       _u_old_neighbor.resize(nqp);
 
     if (_need_u_older_neighbor)
       _u_older_neighbor.resize(nqp);
 
     if (_need_grad_old_neighbor)
       _grad_u_old_neighbor.resize(nqp);
 
     if (_need_grad_older_neighbor)
       _grad_u_older_neighbor.resize(nqp);
 
     if (_need_second_old_neighbor)
       _second_u_old_neighbor.resize(nqp);
 
     if (_need_second_older_neighbor)
       _second_u_older_neighbor.resize(nqp);
   }
 
   if (_need_dof_values_neighbor)
     _dof_values_neighbor.resize(1);
   if (is_transient)
   {
     if (_need_dof_values_old_neighbor)
       _dof_values_old_neighbor.resize(1);
     if (_need_dof_values_older_neighbor)
       _dof_values_older_neighbor.resize(1);
     if (_need_dof_values_dot_neighbor)
       _dof_values_dot_neighbor.resize(1);
     if (_need_dof_values_dotdot_neighbor)
       _dof_values_dotdot_neighbor.resize(1);
     if (_need_dof_values_dot_old_neighbor)
       _dof_values_dot_old_neighbor.resize(1);
     if (_need_dof_values_dotdot_old_neighbor)
       _dof_values_dotdot_old_neighbor.resize(1);
   }
 
   const dof_id_type & idx = _dof_indices_neighbor[0];
   const Real & soln = (*_sys.currentSolution())(idx);
   Real soln_old = 0;
   Real soln_older = 0;
   Real u_dot = 0;
   Real u_dotdot = 0;
   Real u_dot_old = 0;
   Real u_dotdot_old = 0;
   const Real & du_dot_du = _sys.duDotDu();
   const Real & du_dotdot_du = _sys.duDotDotDu();
 
   if (_need_dof_values_neighbor)
     _dof_values_neighbor[0] = soln;
 
   if (is_transient)
   {
     if (_need_u_old_neighbor || _need_grad_old_neighbor || _need_second_old_neighbor ||
         _need_dof_values_old_neighbor)
       soln_old = _sys.solutionOld()(idx);
 
     if (_need_u_older_neighbor || _need_grad_older_neighbor || _need_second_older_neighbor ||
         _need_dof_values_older_neighbor)
       soln_older = _sys.solutionOlder()(idx);
 
     if (_need_dof_values_old_neighbor)
       _dof_values_old_neighbor[0] = soln_old;
     if (_need_dof_values_older_neighbor)
       _dof_values_older_neighbor[0] = soln_older;
 
     if (_sys.solutionUDot())
       u_dot = (*_sys.solutionUDot())(idx);
     if (_sys.solutionUDotDot())
       u_dotdot = (*_sys.solutionUDotDot())(idx);
     if (_sys.solutionUDotOld())
       u_dot_old = (*_sys.solutionUDotOld())(idx);
     if (_sys.solutionUDotDotOld())
       u_dotdot_old = (*_sys.solutionUDotDotOld())(idx);
 
     if (_need_dof_values_dot_neighbor)
       _dof_values_dot_neighbor[0] = u_dot;
 
     if (_need_dof_values_dotdot_neighbor)
       _dof_values_dotdot_neighbor[0] = u_dotdot;
 
     if (_need_dof_values_dot_old_neighbor)
       _dof_values_dot_old_neighbor[0] = u_dot_old;
 
     if (_need_dof_values_dotdot_old_neighbor)
       _dof_values_dotdot_old_neighbor[0] = u_dotdot_old;
   }
 
   _u_neighbor[0] = phi * soln;
 
   if (is_transient)
   {
     if (_need_u_dot_neighbor)
       _u_dot_neighbor[0] = phi * u_dot;
 
     if (_need_u_dotdot_neighbor)
       _u_dotdot_neighbor[0] = phi * u_dotdot;
 
     if (_need_u_dot_old_neighbor)
       _u_dot_old_neighbor[0] = phi * u_dot_old;
 
     if (_need_u_dotdot_old_neighbor)
       _u_dotdot_old_neighbor[0] = phi * u_dotdot_old;
 
     if (_need_du_dot_du_neighbor)
       _du_dot_du_neighbor[0] = du_dot_du;
 
     if (_need_du_dotdot_du_neighbor)
       _du_dotdot_du_neighbor[0] = du_dotdot_du;
 
     if (_need_u_old_neighbor)
       _u_old_neighbor[0] = phi * soln_old;
 
     if (_need_u_older_neighbor)
       _u_older_neighbor[0] = phi * soln_older;
   }
 
   for (unsigned qp = 1; qp < nqp; ++qp)
   {
     _u_neighbor[qp] = _u_neighbor[0];
 
     if (is_transient)
     {
       if (_need_u_dot_neighbor)
         _u_dot_neighbor[qp] = _u_dot_neighbor[0];
 
       if (_need_u_dotdot_neighbor)
         _u_dotdot_neighbor[qp] = _u_dotdot_neighbor[0];
 
       if (_need_u_dot_old_neighbor)
         _u_dot_old_neighbor[qp] = _u_dot_old_neighbor[0];
 
       if (_need_u_dotdot_old_neighbor)
         _u_dotdot_old_neighbor[qp] = _u_dotdot_old_neighbor[0];
 
       if (_need_du_dot_du_neighbor)
         _du_dot_du_neighbor[qp] = _du_dot_du_neighbor[0];
 
       if (_need_du_dotdot_du_neighbor)
         _du_dotdot_du_neighbor[qp] = _du_dotdot_du_neighbor[0];
 
       if (_need_u_old_neighbor)
         _u_old_neighbor[qp] = _u_old_neighbor[0];
 
       if (_need_u_older_neighbor)
         _u_older_neighbor[qp] = _u_older_neighbor[0];
     }
   }
 }

◆ computeMonomialValuesHelper()

void MooseVariableConstMonomial::computeMonomialValuesHelper	(	const unsigned &	nqp,
		const Real &	phi
	)

virtual

Definition at line 28 of file MooseVariableConstMonomial.C.

Referenced by computeElemValues(), and computeElemValuesFace().

 {
   bool is_transient = _subproblem.isTransient();
 
   _u.resize(nqp);
   _grad_u.resize(nqp);
 
   if (_need_second)
     _second_u.resize(nqp);
 
   if (_need_u_previous_nl)
     _u_previous_nl.resize(nqp);
 
   if (_need_grad_previous_nl)
     _grad_u_previous_nl.resize(nqp);
 
   if (_need_second_previous_nl)
     _second_u_previous_nl.resize(nqp);
 
   if (is_transient)
   {
     if (_need_u_dot)
       _u_dot.resize(nqp);
 
     if (_need_u_dotdot)
       _u_dotdot.resize(nqp);
 
     if (_need_u_dot_old)
       _u_dot_old.resize(nqp);
 
     if (_need_u_dotdot_old)
       _u_dotdot_old.resize(nqp);
 
     if (_need_du_dot_du)
       _du_dot_du.resize(nqp);
 
     if (_need_du_dotdot_du)
       _du_dotdot_du.resize(nqp);
 
     if (_need_u_old)
       _u_old.resize(nqp);
 
     if (_need_u_older)
       _u_older.resize(nqp);
 
     if (_need_grad_old)
       _grad_u_old.resize(nqp);
 
     if (_need_grad_older)
       _grad_u_older.resize(nqp);
 
     if (_need_second_old)
       _second_u_old.resize(nqp);
 
     if (_need_second_older)
       _second_u_older.resize(nqp);
   }
 
   if (_need_dof_values)
     _dof_values.resize(1);
 
   if (_need_dof_values_previous_nl)
     _dof_values_previous_nl.resize(1);
 
   if (is_transient)
   {
     if (_need_dof_values_old)
       _dof_values_old.resize(1);
     if (_need_dof_values_older)
       _dof_values_older.resize(1);
     if (_need_dof_values_dot)
       _dof_values_dot.resize(1);
     if (_need_dof_values_dotdot)
       _dof_values_dotdot.resize(1);
     if (_need_dof_values_dot_old)
       _dof_values_dot_old.resize(1);
     if (_need_dof_values_dotdot_old)
       _dof_values_dotdot_old.resize(1);
   }
 
   const dof_id_type & idx = _dof_indices[0];
   const Real & soln = (*_sys.currentSolution())(idx);
   Real soln_old = 0;
   Real soln_older = 0;
   Real soln_previous_nl = 0;
   Real u_dot = 0;
   Real u_dotdot = 0;
   Real u_dot_old = 0;
   Real u_dotdot_old = 0;
   const Real & du_dot_du = _sys.duDotDu();
   const Real & du_dotdot_du = _sys.duDotDotDu();
 
   if (_need_dof_values)
     _dof_values[0] = soln;
 
   if (_need_u_previous_nl || _need_grad_previous_nl || _need_second_previous_nl ||
       _need_dof_values_previous_nl)
     soln_previous_nl = (*_sys.solutionPreviousNewton())(idx);
 
   if (_need_dof_values_previous_nl)
     _dof_values_previous_nl[0] = soln_previous_nl;
 
   if (is_transient)
   {
     if (_need_u_old || _need_grad_old || _need_second_old || _need_dof_values_old)
       soln_old = _sys.solutionOld()(idx);
 
     if (_need_u_older || _need_grad_older || _need_second_older || _need_dof_values_older)
       soln_older = _sys.solutionOlder()(idx);
 
     if (_need_dof_values_old)
       _dof_values_old[0] = soln_old;
 
     if (_need_dof_values_older)
       _dof_values_older[0] = soln_older;
 
     if (_sys.solutionUDot())
       u_dot = (*_sys.solutionUDot())(idx);
     if (_sys.solutionUDotDot())
       u_dotdot = (*_sys.solutionUDotDot())(idx);
     if (_sys.solutionUDotOld())
       u_dot_old = (*_sys.solutionUDotOld())(idx);
     if (_sys.solutionUDotDotOld())
       u_dotdot_old = (*_sys.solutionUDotDotOld())(idx);
 
     if (_need_dof_values_dot)
       _dof_values_dot[0] = u_dot;
 
     if (_need_dof_values_dotdot)
       _dof_values_dotdot[0] = u_dotdot;
   }
 
   _u[0] = phi * soln;
 
   if (_need_u_previous_nl)
     _u_previous_nl[0] = phi * soln_previous_nl;
 
   if (is_transient)
   {
     if (_need_u_dot)
       _u_dot[0] = phi * u_dot;
 
     if (_need_u_dotdot)
       _u_dotdot[0] = phi * u_dotdot;
 
     if (_need_u_dot_old)
       _u_dot_old[0] = phi * u_dot_old;
 
     if (_need_u_dotdot_old)
       _u_dotdot_old[0] = phi * u_dotdot_old;
 
     if (_need_du_dot_du)
       _du_dot_du[0] = du_dot_du;
 
     if (_need_du_dotdot_du)
       _du_dotdot_du[0] = du_dotdot_du;
 
     if (_need_u_old)
       _u_old[0] = phi * soln_old;
 
     if (_need_u_older)
       _u_older[0] = phi * soln_older;
   }
 
   for (unsigned qp = 1; qp < nqp; ++qp)
   {
     _u[qp] = _u[0];
 
     if (_need_u_previous_nl)
       _u_previous_nl[qp] = _u_previous_nl[0];
 
     if (is_transient)
     {
       if (_need_u_dot)
         _u_dot[qp] = _u_dot[0];
 
       if (_need_u_dotdot)
         _u_dotdot[qp] = _u_dotdot[0];
 
       if (_need_u_dot_old)
         _u_dot_old[qp] = _u_dot_old[0];
 
       if (_need_u_dotdot_old)
         _u_dotdot_old[qp] = _u_dotdot_old[0];
 
       if (_need_du_dot_du)
         _du_dot_du[qp] = _du_dot_du[0];
 
       if (_need_du_dotdot_du)
         _du_dotdot_du[qp] = _du_dotdot_du[0];
 
       if (_need_u_old)
         _u_old[qp] = _u_old[0];
 
       if (_need_u_older)
         _u_older[qp] = _u_older[qp];
     }
   }
 }

◆ computeNeighborValues()

void MooseVariableConstMonomial::computeNeighborValues ( )

overridevirtual

Compute values at quadrature points for the neighbor.

Reimplemented from MooseVariableFE< Real >.

Definition at line 429 of file MooseVariableConstMonomial.C.

 {
   if (_dof_indices_neighbor.size() == 0)
     return;
 
   computeMonomialNeighborValuesHelper(_qrule_neighbor->n_points(), _phi_neighbor[0][0]);
 }

◆ computeNeighborValuesFace()

void MooseVariableConstMonomial::computeNeighborValuesFace ( )

overridevirtual

Compute values at facial quadrature points for the neighbor.

Reimplemented from MooseVariableFE< Real >.

Definition at line 438 of file MooseVariableConstMonomial.C.

 {
   if (_dof_indices_neighbor.size() == 0)
     return;
 
   computeMonomialNeighborValuesHelper(_qrule_neighbor->n_points(), _phi_face_neighbor[0][0]);
 }

◆ computeNeighborValuesHelper()

void MooseVariableFE< Real >::computeNeighborValuesHelper	(	QBase *&	qrule,
		const FieldVariablePhiValue &	phi,
		const FieldVariablePhiGradient &	grad_phi,
		const FieldVariablePhiSecond *&	second_phi
	)

virtualinherited

Helper function for computing values.

Definition at line 1371 of file MooseVariableFE.C.

 {
   unsigned int num_dofs = _dof_indices_neighbor.size();
 
   if (num_dofs > 0)
     fetchDoFValuesNeighbor();
 
   bool is_transient = _subproblem.isTransient();
   unsigned int nqp = qrule->n_points();
 
   _u_neighbor.resize(nqp);
   _grad_u_neighbor.resize(nqp);
 
   if (_need_second_neighbor)
     _second_u_neighbor.resize(nqp);
 
   if (is_transient)
   {
     if (_need_u_dot_neighbor)
       _u_dot_neighbor.resize(nqp);
 
     if (_need_u_dotdot_neighbor)
       _u_dotdot_neighbor.resize(nqp);
 
     if (_need_u_dot_old_neighbor)
       _u_dot_old_neighbor.resize(nqp);
 
     if (_need_u_dotdot_old_neighbor)
       _u_dotdot_old_neighbor.resize(nqp);
 
     if (_need_du_dot_du_neighbor)
       _du_dot_du_neighbor.resize(nqp);
 
     if (_need_du_dotdot_du_neighbor)
       _du_dotdot_du_neighbor.resize(nqp);
 
     if (_need_grad_neighbor_dot)
       _grad_u_neighbor_dot.resize(nqp);
 
     if (_need_grad_neighbor_dotdot)
       _grad_u_neighbor_dotdot.resize(nqp);
 
     if (_need_u_old_neighbor)
       _u_old_neighbor.resize(nqp);
 
     if (_need_u_older_neighbor)
       _u_older_neighbor.resize(nqp);
 
     if (_need_grad_old_neighbor)
       _grad_u_old_neighbor.resize(nqp);
 
     if (_need_grad_older_neighbor)
       _grad_u_older_neighbor.resize(nqp);
 
     if (_need_second_old_neighbor)
       _second_u_old_neighbor.resize(nqp);
 
     if (_need_second_older_neighbor)
       _second_u_older_neighbor.resize(nqp);
   }
 
   for (unsigned int i = 0; i < nqp; ++i)
   {
     _u_neighbor[i] = 0;
     _grad_u_neighbor[i] = 0;
 
     if (_need_second_neighbor)
       _second_u_neighbor[i] = 0;
 
     if (_need_grad_dot)
       _grad_u_neighbor_dot[i] = 0;
     if (_need_grad_dotdot)
       _grad_u_neighbor_dotdot[i] = 0;
 
     if (is_transient)
     {
       if (_need_u_dot_neighbor)
         _u_dot_neighbor[i] = 0;
 
       if (_need_u_dotdot_neighbor)
         _u_dotdot_neighbor[i] = 0;
 
       if (_need_u_dot_old_neighbor)
         _u_dot_old_neighbor[i] = 0;
 
       if (_need_u_dotdot_old_neighbor)
         _u_dotdot_old_neighbor[i] = 0;
 
       if (_need_du_dot_du_neighbor)
         _du_dot_du_neighbor[i] = 0;
 
       if (_need_du_dotdot_du_neighbor)
         _du_dotdot_du_neighbor[i] = 0;
 
       if (_need_u_old_neighbor)
         _u_old_neighbor[i] = 0;
 
       if (_need_u_older_neighbor)
         _u_older_neighbor[i] = 0;
 
       if (_need_grad_old_neighbor)
         _grad_u_old_neighbor[i] = 0;
 
       if (_need_grad_older_neighbor)
         _grad_u_older_neighbor[i] = 0;
 
       if (_need_second_old_neighbor)
         _second_u_old_neighbor[i] = 0;
 
       if (_need_second_older_neighbor)
         _second_u_older_neighbor[i] = 0;
     }
   }
 
   bool second_required =
       _need_second_neighbor || _need_second_old_neighbor || _need_second_older_neighbor;
 
   for (unsigned int i = 0; i < num_dofs; ++i)
   {
     for (unsigned int qp = 0; qp < nqp; ++qp)
     {
       OutputType phi_local = phi[i][qp];
       typename OutputTools<OutputType>::OutputGradient dphi_local = grad_phi[i][qp];
 
       _u_neighbor[qp] += phi_local * _dof_values_neighbor[i];
 
       _grad_u_neighbor[qp] += dphi_local * _dof_values_neighbor[i];
 
       if (is_transient)
       {
         if (_need_u_dot_neighbor)
           _u_dot_neighbor[qp] += phi_local * _dof_values_dot_neighbor[i];
 
         if (_need_u_dotdot_neighbor)
           _u_dotdot_neighbor[qp] += phi_local * _dof_values_dotdot_neighbor[i];
 
         if (_need_u_dot_old_neighbor)
           _u_dot_old_neighbor[qp] += phi_local * _dof_values_dot_old_neighbor[i];
 
         if (_need_u_dotdot_old_neighbor)
           _u_dotdot_old_neighbor[qp] += phi_local * _dof_values_dotdot_old_neighbor[i];
 
         if (_need_du_dot_du_neighbor)
           _du_dot_du_neighbor[qp] = _dof_du_dot_du_neighbor[i];
 
         if (_need_du_dotdot_du_neighbor)
           _du_dotdot_du_neighbor[qp] = _dof_du_dotdot_du_neighbor[i];
 
         if (_need_grad_neighbor_dot)
           _grad_u_neighbor_dot[qp].add_scaled(dphi_local, _dof_values_dot_neighbor[i]);
 
         if (_need_grad_neighbor_dotdot)
           _grad_u_neighbor_dotdot[qp].add_scaled(dphi_local, _dof_values_dotdot_neighbor[i]);
 
         if (_need_u_old_neighbor)
           _u_old_neighbor[qp] += phi_local * _dof_values_old_neighbor[i];
 
         if (_need_u_older_neighbor)
           _u_older_neighbor[qp] += phi_local * _dof_values_older_neighbor[i];
 
         if (_need_grad_old_neighbor)
           _grad_u_old_neighbor[qp] += dphi_local * _dof_values_old_neighbor[i];
 
         if (_need_grad_older_neighbor)
           _grad_u_older_neighbor[qp] += dphi_local * _dof_values_older_neighbor[i];
       }
 
       if (second_required)
       {
         libmesh_assert(second_phi);
         typename OutputTools<OutputType>::OutputSecond d2phi_local = (*second_phi)[i][qp];
 
         if (_need_second_neighbor)
           _second_u_neighbor[qp] += d2phi_local * _dof_values_neighbor[i];
 
         if (is_transient)
         {
           if (_need_second_old_neighbor)
             _second_u_old_neighbor[qp] += d2phi_local * _dof_values_old_neighbor[i];
 
           if (_need_second_older_neighbor)
             _second_u_older_neighbor[qp] += d2phi_local * _dof_values_older_neighbor[i];
         }
       }
     }
   }
 
   // Automatic differentiation
   if (_need_neighbor_ad && _subproblem.currentlyComputingJacobian())
     computeADNeighbor(num_dofs, nqp, is_transient, phi, grad_phi, second_phi);
 }

◆ computeNodalNeighborValues()

void MooseVariableFE< Real >::computeNodalNeighborValues ( )

overridevirtualinherited

Compute nodal values of this variable in the neighbor.

Implements MooseVariableFEBase.

Definition at line 1908 of file MooseVariableFE.C.

 {
   if (_neighbor_has_dof_indices)
   {
     fetchDoFValuesNeighbor();
     assignNodalValueNeighbor();
   }
   else
     zeroSizeDofValuesNeighbor();
 }

◆ computeNodalValues()

void MooseVariableFE< Real >::computeNodalValues ( )

overridevirtualinherited

Compute nodal values of this variable.

Implements MooseVariableFEBase.

Definition at line 1892 of file MooseVariableFE.C.

 {
   if (_has_dof_indices)
   {
     fetchDoFValues();
     assignNodalValue();
 
     if (_need_ad && _subproblem.currentlyComputingJacobian())
       fetchADDoFValues();
   }
   else
     zeroSizeDofValues();
 }

◆ computeValuesHelper()

void MooseVariableFE< Real >::computeValuesHelper	(	QBase *&	qrule,
		const FieldVariablePhiValue &	phi,
		const FieldVariablePhiGradient &	grad_phi,
		const FieldVariablePhiSecond *&	second_phi,
		const FieldVariablePhiCurl *&	curl_phi,
		const typename VariableTestGradientType< Real , JACOBIAN >::type &	ad_grad_phi
	)

virtualinherited

Helper function for computing values.

Definition at line 902 of file MooseVariableFE.C.

 {
   unsigned int num_dofs = _dof_indices.size();
 
   if (num_dofs > 0)
     fetchDoFValues();
 
   bool is_transient = _subproblem.isTransient();
   unsigned int nqp = qrule->n_points();
   auto & active_coupleable_vector_tags =
       _sys.subproblem().getActiveFEVariableCoupleableVectorTags(_tid);
   auto & active_coupleable_matrix_tags =
       _sys.subproblem().getActiveFEVariableCoupleableMatrixTags(_tid);
 
   _u.resize(nqp);
   _grad_u.resize(nqp);
 
   for (auto tag : active_coupleable_vector_tags)
     if (_need_vector_tag_u[tag])
       _vector_tag_u[tag].resize(nqp);
 
   for (auto tag : active_coupleable_matrix_tags)
     if (_need_matrix_tag_u[tag])
       _matrix_tag_u[tag].resize(nqp);
 
   if (_need_second)
     _second_u.resize(nqp);
 
   if (_need_curl)
     _curl_u.resize(nqp);
 
   if (_need_u_previous_nl)
     _u_previous_nl.resize(nqp);
 
   if (_need_grad_previous_nl)
     _grad_u_previous_nl.resize(nqp);
 
   if (_need_second_previous_nl)
     _second_u_previous_nl.resize(nqp);
 
   if (is_transient)
   {
     if (_need_u_dot)
       _u_dot.resize(nqp);
 
     if (_need_u_dotdot)
       _u_dotdot.resize(nqp);
 
     if (_need_u_dot_old)
       _u_dot_old.resize(nqp);
 
     if (_need_u_dotdot_old)
       _u_dotdot_old.resize(nqp);
 
     if (_need_du_dot_du)
       _du_dot_du.resize(nqp);
 
     if (_need_du_dotdot_du)
       _du_dotdot_du.resize(nqp);
 
     if (_need_grad_dot)
       _grad_u_dot.resize(nqp);
 
     if (_need_grad_dotdot)
       _grad_u_dotdot.resize(nqp);
 
     if (_need_u_old)
       _u_old.resize(nqp);
 
     if (_need_u_older)
       _u_older.resize(nqp);
 
     if (_need_grad_old)
       _grad_u_old.resize(nqp);
 
     if (_need_grad_older)
       _grad_u_older.resize(nqp);
 
     if (_need_second_old)
       _second_u_old.resize(nqp);
 
     if (_need_curl_old)
       _curl_u_old.resize(nqp);
 
     if (_need_second_older)
       _second_u_older.resize(nqp);
   }
 
   for (unsigned int i = 0; i < nqp; ++i)
   {
     _u[i] = 0;
     _grad_u[i] = 0;
 
     for (auto tag : active_coupleable_vector_tags)
       if (_need_vector_tag_u[tag])
         _vector_tag_u[tag][i] = 0;
 
     for (auto tag : active_coupleable_matrix_tags)
       if (_need_matrix_tag_u[tag])
         _matrix_tag_u[tag][i] = 0;
 
     if (_need_second)
       _second_u[i] = 0;
 
     if (_need_curl)
       _curl_u[i] = 0;
 
     if (_need_u_previous_nl)
       _u_previous_nl[i] = 0;
 
     if (_need_grad_previous_nl)
       _grad_u_previous_nl[i] = 0;
 
     if (_need_second_previous_nl)
       _second_u_previous_nl[i] = 0;
 
     if (is_transient)
     {
       if (_need_u_dot)
         _u_dot[i] = 0;
 
       if (_need_u_dotdot)
         _u_dotdot[i] = 0;
 
       if (_need_u_dot_old)
         _u_dot_old[i] = 0;
 
       if (_need_u_dotdot_old)
         _u_dotdot_old[i] = 0;
 
       if (_need_du_dot_du)
         _du_dot_du[i] = 0;
 
       if (_need_du_dotdot_du)
         _du_dotdot_du[i] = 0;
 
       if (_need_grad_dot)
         _grad_u_dot[i] = 0;
 
       if (_need_grad_dotdot)
         _grad_u_dotdot[i] = 0;
 
       if (_need_u_old)
         _u_old[i] = 0;
 
       if (_need_u_older)
         _u_older[i] = 0;
 
       if (_need_grad_old)
         _grad_u_old[i] = 0;
 
       if (_need_grad_older)
         _grad_u_older[i] = 0;
 
       if (_need_second_old)
         _second_u_old[i] = 0;
 
       if (_need_second_older)
         _second_u_older[i] = 0;
 
       if (_need_curl_old)
         _curl_u_old[i] = 0;
     }
   }
 
   bool second_required =
       _need_second || _need_second_old || _need_second_older || _need_second_previous_nl;
   bool curl_required = _need_curl || _need_curl_old;
 
   for (unsigned int i = 0; i < num_dofs; i++)
   {
     for (unsigned int qp = 0; qp < nqp; qp++)
     {
       const OutputType phi_local = phi[i][qp];
       const typename OutputTools<OutputType>::OutputGradient dphi_qp = grad_phi[i][qp];
 
       _u[qp] += phi_local * _dof_values[i];
 
       _grad_u[qp].add_scaled(dphi_qp, _dof_values[i]);
 
       if (is_transient)
       {
         if (_need_u_old)
           _u_old[qp] += phi_local * _dof_values_old[i];
 
         if (_need_u_older)
           _u_older[qp] += phi_local * _dof_values_older[i];
 
         if (_need_grad_old)
           _grad_u_old[qp].add_scaled(dphi_qp, _dof_values_old[i]);
 
         if (_need_grad_older)
           _grad_u_older[qp].add_scaled(dphi_qp, _dof_values_older[i]);
 
         if (_need_u_dot)
           _u_dot[qp] += phi_local * _dof_values_dot[i];
 
         if (_need_u_dotdot)
           _u_dotdot[qp] += phi_local * _dof_values_dotdot[i];
 
         if (_need_u_dot_old)
           _u_dot_old[qp] += phi_local * _dof_values_dot_old[i];
 
         if (_need_u_dotdot_old)
           _u_dotdot_old[qp] += phi_local * _dof_values_dotdot_old[i];
 
         if (_need_grad_dot)
           _grad_u_dot[qp].add_scaled(dphi_qp, _dof_values_dot[i]);
 
         if (_need_grad_dotdot)
           _grad_u_dotdot[qp].add_scaled(dphi_qp, _dof_values_dotdot[i]);
 
         if (_need_du_dot_du)
           _du_dot_du[qp] = _dof_du_dot_du[i];
 
         if (_need_du_dotdot_du)
           _du_dotdot_du[qp] = _dof_du_dotdot_du[i];
       }
 
       if (second_required)
       {
         libmesh_assert(second_phi);
         const typename OutputTools<OutputType>::OutputSecond d2phi_local = (*second_phi)[i][qp];
 
         if (_need_second)
           _second_u[qp].add_scaled(d2phi_local, _dof_values[i]);
 
         if (_need_second_previous_nl)
           _second_u_previous_nl[qp].add_scaled(d2phi_local, _dof_values_previous_nl[i]);
 
         if (is_transient)
         {
           if (_need_second_old)
             _second_u_old[qp].add_scaled(d2phi_local, _dof_values_old[i]);
 
           if (_need_second_older)
             _second_u_older[qp].add_scaled(d2phi_local, _dof_values_older[i]);
         }
       }
 
       if (curl_required)
       {
         libmesh_assert(curl_phi);
         const OutputType curl_phi_local = (*curl_phi)[i][qp];
 
         if (_need_curl)
           _curl_u[qp] += curl_phi_local * _dof_values[i];
 
         if (is_transient && _need_curl_old)
           _curl_u_old[qp] += curl_phi_local * _dof_values_old[i];
       }
 
       for (auto tag : active_coupleable_vector_tags)
         if (_need_vector_tag_u[tag])
           _vector_tag_u[tag][qp] += phi_local * _vector_tags_dof_u[tag][i];
 
       for (auto tag : active_coupleable_matrix_tags)
         if (_need_matrix_tag_u[tag])
           _matrix_tag_u[tag][qp] += phi_local * _matrix_tags_dof_u[tag][i];
 
       if (_need_u_previous_nl)
         _u_previous_nl[qp] += phi_local * _dof_values_previous_nl[i];
 
       if (_need_grad_previous_nl)
         _grad_u_previous_nl[qp].add_scaled(dphi_qp, _dof_values_previous_nl[i]);
     }
   }
 
   // Automatic differentiation
   if (_need_ad && _subproblem.currentlyComputingJacobian())
     computeAD(num_dofs, nqp, is_transient, phi, grad_phi, second_phi, ad_grad_phi);
 }

◆ computingCurl()

bool MooseVariableFE< Real >::computingCurl ( )

inlineinherited

Whether or not this variable is computing the curl.

Definition at line 133 of file MooseVariableFE.h.

133 { return _need_curl || _need_curl_old; }

MooseVariableFE< Real >::_need_curl_old

bool _need_curl_old

Definition: MooseVariableFE.h:829

MooseVariableFE< Real >::_need_curl

bool _need_curl

Definition: MooseVariableFE.h:828

◆ computingSecond()

bool MooseVariableFE< Real >::computingSecond ( )

inlineinherited

Whether or not this variable is computing any second derivatives.

Definition at line 129 of file MooseVariableFE.h.

129 { return usesSecondPhi(); }

MooseVariableFE< Real >::usesSecondPhi

bool usesSecondPhi()

Whether or not this variable is computing any second derivatives.

Definition: MooseVariableFE.h:114

◆ curlPhi()

const MooseVariableFE< Real >::FieldVariablePhiCurl & MooseVariableFE< Real >::curlPhi ( )

inherited

Definition at line 2547 of file MooseVariableFE.C.

 {
   _curl_phi = &_assembly.feCurlPhi<OutputType>(_fe_type);
   return *_curl_phi;
 }

◆ curlPhiFace()

const MooseVariableFE< Real >::FieldVariablePhiCurl & MooseVariableFE< Real >::curlPhiFace ( )

inherited

Definition at line 2563 of file MooseVariableFE.C.

 {
   _curl_phi_face = &_assembly.feCurlPhiFace<OutputType>(_fe_type);
   return *_curl_phi_face;
 }

◆ curlPhiFaceNeighbor()

const MooseVariableFE< Real >::FieldVariablePhiCurl & MooseVariableFE< Real >::curlPhiFaceNeighbor ( )

inherited

Definition at line 2595 of file MooseVariableFE.C.

 {
   _curl_phi_face_neighbor = &_assembly.feCurlPhiFaceNeighbor<OutputType>(_fe_type);
   return *_curl_phi_face_neighbor;
 }

◆ curlPhiNeighbor()

const MooseVariableFE< Real >::FieldVariablePhiCurl & MooseVariableFE< Real >::curlPhiNeighbor ( )

inherited

Definition at line 2579 of file MooseVariableFE.C.

 {
   _curl_phi_neighbor = &_assembly.feCurlPhiNeighbor<OutputType>(_fe_type);
   return *_curl_phi_neighbor;
 }

◆ curlSln()

const FieldVariableCurl& MooseVariableFE< Real >::curlSln ( )

inlineinherited

Definition at line 292 of file MooseVariableFE.h.

   {
     _need_curl = true;
     curlPhi();
     curlPhiFace();
     return _curl_u;
   }

◆ curlSlnNeighbor()

const FieldVariableCurl& MooseVariableFE< Real >::curlSlnNeighbor ( )

inlineinherited

Definition at line 516 of file MooseVariableFE.h.

   {
     _need_curl_neighbor = true;
     curlPhiFaceNeighbor();
     return _curl_u_neighbor;
   }

◆ curlSlnOld()

const FieldVariableCurl& MooseVariableFE< Real >::curlSlnOld ( )

inlineinherited

Definition at line 299 of file MooseVariableFE.h.

   {
     _need_curl_old = true;
     curlPhi();
     curlPhiFace();
     return _curl_u_old;
   }

◆ curlSlnOlder()

const FieldVariableCurl& MooseVariableFE< Real >::curlSlnOlder ( )

inlineinherited

Definition at line 306 of file MooseVariableFE.h.

   {
     _need_curl_older = true;
     curlPhi();
     curlPhiFace();
     return _curl_u_older;
   }

◆ curlSlnOlderNeighbor()

const FieldVariableCurl& MooseVariableFE< Real >::curlSlnOlderNeighbor ( )

inlineinherited

Definition at line 528 of file MooseVariableFE.h.

   {
     _need_curl_older_neighbor = true;
     curlPhiFaceNeighbor();
     return _curl_u_older_neighbor;
   }

◆ curlSlnOldNeighbor()

const FieldVariableCurl& MooseVariableFE< Real >::curlSlnOldNeighbor ( )

inlineinherited

Definition at line 522 of file MooseVariableFE.h.

   {
     _need_curl_old_neighbor = true;
     curlPhiFaceNeighbor();
     return _curl_u_old_neighbor;
   }

◆ currentElem()

const Elem*& MooseVariableFE< Real >::currentElem ( ) const

inlineoverridevirtualinherited

Current element this variable is evaluated at.

Implements MooseVariableFEBase.

Definition at line 148 of file MooseVariableFE.h.

148 { return _elem; }

MooseVariableFE< Real >::_elem

const Elem *& _elem

current element

Definition: MooseVariableFE.h:795

◆ currentSide()

unsigned int& MooseVariableFE< Real >::currentSide ( ) const

inlineinherited

Current side this variable is being evaluated on.

Definition at line 153 of file MooseVariableFE.h.

153 { return _current_side; }

MooseVariableFE< Real >::_current_side

unsigned int & _current_side

the side of the current element (valid when doing face assembly)

Definition: MooseVariableFE.h:797

◆ dofIndices() [1/2]

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

inlineinherited

Get a writable reference of local DoF indices.

Definition at line 93 of file MooseVariableBase.h.

Referenced by Assembly::addJacobianCoupledVarPair(), Assembly::cacheJacobianCoupledVarPair(), AuxScalarKernel::compute(), VectorNodalBC::computeJacobian(), NonlocalIntegratedBC::computeJacobian(), NonlocalKernel::computeJacobian(), NodalConstraint::computeJacobian(), NonlocalIntegratedBC::computeJacobianBlock(), NonlocalKernel::computeNonlocalJacobian(), NonlocalIntegratedBC::computeNonlocalJacobian(), NonlocalKernel::computeNonlocalOffDiagJacobian(), NonlocalIntegratedBC::computeNonlocalOffDiagJacobian(), VectorNodalBC::computeOffDiagJacobian(), NonlocalKernel::computeOffDiagJacobian(), VectorNodalBC::computeResidual(), NodalConstraint::computeResidual(), MultiAppPostprocessorToAuxScalarTransfer::execute(), MultiAppScalarToAuxScalarTransfer::execute(), ScalarVariable::getValue(), TableOutput::outputScalarVariables(), Nemesis::outputScalarVariables(), Exodus::outputScalarVariables(), Assembly::prepareJacobianBlock(), Assembly::prepareNeighbor(), Assembly::prepareNonlocal(), Assembly::prepareVariable(), Assembly::prepareVariableNonlocal(), and FEProblemBase::projectSolution().

93 { return _dof_indices; }

MooseVariableBase::_dof_indices

std::vector< dof_id_type > _dof_indices

DOF indices.

Definition: MooseVariableBase.h:120

◆ dofIndices() [2/2]

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

inlineinherited

Get local DoF indices.

Definition at line 96 of file MooseVariableBase.h.

96 { return _dof_indices; }

MooseVariableBase::_dof_indices

std::vector< dof_id_type > _dof_indices

DOF indices.

Definition: MooseVariableBase.h:120

◆ dofIndicesNeighbor()

std::vector<dof_id_type>& MooseVariableFE< Real >::dofIndicesNeighbor ( )

inlineoverridevirtualinherited

Get neighbor DOF indices for currently selected element.

Returns: the neighbor degree of freedom indices

Implements MooseVariableFEBase.

Definition at line 631 of file MooseVariableFE.h.

631 { return _dof_indices_neighbor; }

MooseVariableFE< Real >::_dof_indices_neighbor

std::vector< dof_id_type > _dof_indices_neighbor

DOF indices (neighbor)

Definition: MooseVariableFE.h:803

◆ dofMap()

const DofMap& MooseVariableBase::dofMap ( ) const

inlineinherited

The DofMap associated with the system this variable is in.

Definition at line 90 of file MooseVariableBase.h.

Referenced by AuxScalarKernel::compute(), and ScalarVariable::getValue().

90 { return _dof_map; }

MooseVariableBase::_dof_map

const DofMap & _dof_map

DOF map.

Definition: MooseVariableBase.h:118

◆ dofValue()

const MooseArray< Number > & MooseVariableFE< Real >::dofValue ( )

overridevirtualinherited

Deprecated method.

Use dofValues

Implements MooseVariableFEBase.

Definition at line 582 of file MooseVariableFE.C.

 {
   mooseDeprecated("Use dofValues instead of dofValue");
   return dofValues();
 }

◆ dofValues()

const MooseArray< Number > & MooseVariableFE< Real >::dofValues ( )

overridevirtualinherited

Returns dof solution on element.

Implements MooseVariableFEBase.

Definition at line 590 of file MooseVariableFE.C.

 {
   _need_dof_values = true;
   return _dof_values;
 }

◆ dofValuesDot()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesDot ( )

overridevirtualinherited

Returns time derivative of degrees of freedom.

Implements MooseVariableFEBase.

Definition at line 654 of file MooseVariableFE.C.

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

◆ dofValuesDotDot()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesDotDot ( )

overridevirtualinherited

Returns second time derivative of degrees of freedom.

Implements MooseVariableFEBase.

Definition at line 668 of file MooseVariableFE.C.

 {
   if (_sys.solutionUDotDot())
   {
     _need_dof_values_dotdot = true;
     return _dof_values_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`.");
 }

◆ dofValuesDotDotNeighbor()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesDotDotNeighbor ( )

overridevirtualinherited

Returns second time derivative of neighboring degrees of freedom.

Implements MooseVariableFEBase.

Definition at line 727 of file MooseVariableFE.C.

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

◆ dofValuesDotDotOld()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesDotDotOld ( )

overridevirtualinherited

Returns old second time derivative of degrees of freedom.

Implements MooseVariableFEBase.

Definition at line 698 of file MooseVariableFE.C.

 {
   if (_sys.solutionUDotDotOld())
   {
     _need_dof_values_dotdot_old = true;
     return _dof_values_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`.");
 }

◆ dofValuesDotDotOldNeighbor()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesDotDotOldNeighbor ( )

overridevirtualinherited

Returns old second time derivative of neighboring degrees of freedom.

Implements MooseVariableFEBase.

Definition at line 757 of file MooseVariableFE.C.

 {
   if (_sys.solutionUDotDotOld())
   {
     _need_dof_values_dotdot_old_neighbor = true;
     return _dof_values_dotdot_old_neighbor;
   }
   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`.");
 }

◆ dofValuesDotNeighbor()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesDotNeighbor ( )

overridevirtualinherited

Returns time derivative of neighboring degrees of freedom.

Implements MooseVariableFEBase.

Definition at line 713 of file MooseVariableFE.C.

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

◆ dofValuesDotOld()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesDotOld ( )

overridevirtualinherited

Returns old time derivative of degrees of freedom.

Implements MooseVariableFEBase.

Definition at line 683 of file MooseVariableFE.C.

 {
   if (_sys.solutionUDotOld())
   {
     _need_dof_values_dot_old = true;
     return _dof_values_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`.");
 }

◆ dofValuesDotOldNeighbor()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesDotOldNeighbor ( )

overridevirtualinherited

Returns old time derivative of neighboring degrees of freedom.

Implements MooseVariableFEBase.

Definition at line 742 of file MooseVariableFE.C.

 {
   if (_sys.solutionUDotOld())
   {
     _need_dof_values_dot_old_neighbor = true;
     return _dof_values_dot_old_neighbor;
   }
   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`.");
 }

◆ dofValuesDuDotDotDu()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesDuDotDotDu ( )

overridevirtualinherited

Returns derivative of second time derivative of degrees of freedom.

Implements MooseVariableFEBase.

Definition at line 780 of file MooseVariableFE.C.

 {
   _need_dof_du_dotdot_du = true;
   return _dof_du_dotdot_du;
 }

◆ dofValuesDuDotDotDuNeighbor()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesDuDotDotDuNeighbor ( )

overridevirtualinherited

Returns derivative of second time derivative of neighboring degrees of freedom.

Implements MooseVariableFEBase.

Definition at line 796 of file MooseVariableFE.C.

 {
   _need_dof_du_dotdot_du_neighbor = true;
   return _dof_du_dotdot_du_neighbor;
 }

◆ dofValuesDuDotDu()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesDuDotDu ( )

overridevirtualinherited

Returns derivative of time derivative of degrees of freedom.

Implements MooseVariableFEBase.

Definition at line 772 of file MooseVariableFE.C.

 {
   _need_dof_du_dot_du = true;
   return _dof_du_dot_du;
 }

◆ dofValuesDuDotDuNeighbor()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesDuDotDuNeighbor ( )

overridevirtualinherited

Returns derivative of time derivative of neighboring degrees of freedom.

Implements MooseVariableFEBase.

Definition at line 788 of file MooseVariableFE.C.

 {
   _need_dof_du_dot_du_neighbor = true;
   return _dof_du_dot_du_neighbor;
 }

◆ dofValuesNeighbor()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesNeighbor ( )

overridevirtualinherited

Returns dof solution on neighbor element.

Implements MooseVariableFEBase.

Definition at line 622 of file MooseVariableFE.C.

 {
   _need_dof_values_neighbor = true;
   return _dof_values_neighbor;
 }

◆ dofValuesOld()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesOld ( )

overridevirtualinherited

Returns old dof solution on element.

Implements MooseVariableFEBase.

Definition at line 598 of file MooseVariableFE.C.

 {
   _need_dof_values_old = true;
   return _dof_values_old;
 }

◆ dofValuesOlder()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesOlder ( )

overridevirtualinherited

Returns older dof solution on element.

Implements MooseVariableFEBase.

Definition at line 606 of file MooseVariableFE.C.

 {
   _need_dof_values_older = true;
   return _dof_values_older;
 }

◆ dofValuesOlderNeighbor()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesOlderNeighbor ( )

overridevirtualinherited

Returns older dof solution on neighbor element.

Implements MooseVariableFEBase.

Definition at line 638 of file MooseVariableFE.C.

 {
   _need_dof_values_older_neighbor = true;
   return _dof_values_older_neighbor;
 }

◆ dofValuesOldNeighbor()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesOldNeighbor ( )

overridevirtualinherited

Returns old dof solution on neighbor element.

Implements MooseVariableFEBase.

Definition at line 630 of file MooseVariableFE.C.

 {
   _need_dof_values_old_neighbor = true;
   return _dof_values_old_neighbor;
 }

◆ dofValuesPreviousNL()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesPreviousNL ( )

overridevirtualinherited

Returns previous nl solution on element.

Implements MooseVariableFEBase.

Definition at line 614 of file MooseVariableFE.C.

 {
   _need_dof_values_previous_nl = true;
   return _dof_values_previous_nl;
 }

◆ dofValuesPreviousNLNeighbor()

const MooseArray< Number > & MooseVariableFE< Real >::dofValuesPreviousNLNeighbor ( )

overridevirtualinherited

Returns previous nl solution on neighbor element.

Implements MooseVariableFEBase.

Definition at line 646 of file MooseVariableFE.C.

 {
   _need_dof_values_previous_nl_neighbor = true;
   return _dof_values_previous_nl_neighbor;
 }

◆ duDotDotDu()

const VariableValue& MooseVariableFE< Real >::duDotDotDu ( )

inlineinherited

Definition at line 423 of file MooseVariableFE.h.

   {
     _need_du_dotdot_du = true;
     return _du_dotdot_du;
   }

◆ duDotDotDuNeighbor()

const VariableValue& MooseVariableFE< Real >::duDotDotDuNeighbor ( )

inlineinherited

Definition at line 592 of file MooseVariableFE.h.

   {
     _need_du_dotdot_du_neighbor = true;
     return _du_dotdot_du_neighbor;
   }

◆ duDotDu()

const VariableValue& MooseVariableFE< Real >::duDotDu ( )

inlineinherited

Definition at line 417 of file MooseVariableFE.h.

   {
     _need_du_dot_du = true;
     return _du_dot_du;
   }

◆ duDotDuNeighbor()

const VariableValue& MooseVariableFE< Real >::duDotDuNeighbor ( )

inlineinherited

Definition at line 586 of file MooseVariableFE.h.

   {
     _need_du_dot_du_neighbor = true;
     return _du_dot_du_neighbor;
   }

◆ fetchADDoFValues()

void MooseVariableFE< Real >::fetchADDoFValues ( )

inherited

Definition at line 2026 of file MooseVariableFE.C.

 {
   auto n = _dof_indices.size();
   libmesh_assert(n);
   _ad_dof_values.resize(n);
   auto ad_offset = _var_num * _sys.getMaxVarNDofsPerNode();
 
   for (decltype(n) i = 0; i < n; ++i)
   {
     _ad_dof_values[i] = _dof_values[i];
     if (_var_kind == Moose::VAR_NONLINEAR)
       _ad_dof_values[i].derivatives()[ad_offset + i] = 1.;
     assignADNodalValue(_ad_dof_values[i], i);
   }
 }

◆ fetchDoFValues()

void MooseVariableFE< Real >::fetchDoFValues ( )

inherited

Definition at line 1921 of file MooseVariableFE.C.

 {
   bool is_transient = _subproblem.isTransient();
 
   auto n = _dof_indices.size();
   libmesh_assert(n);
 
   _dof_values.resize(n);
   _sys.currentSolution()->get(_dof_indices, &_dof_values[0]);
 
   if (is_transient)
   {
     if (_need_u_old || _need_grad_old || _need_second_old || _need_curl_old || _need_dof_values_old)
     {
       _dof_values_old.resize(n);
       _sys.solutionOld().get(_dof_indices, &_dof_values_old[0]);
     }
     if (_need_u_older || _need_grad_older || _need_second_older || _need_dof_values_older)
     {
       _dof_values_older.resize(n);
       _sys.solutionOlder().get(_dof_indices, &_dof_values_older[0]);
     }
     if (_need_u_dot || _need_grad_dot || _need_dof_values_dot)
     {
       libmesh_assert(_sys.solutionUDot());
       _dof_values_dot.resize(n);
       _sys.solutionUDot()->get(_dof_indices, &_dof_values_dot[0]);
     }
     if (_need_u_dotdot || _need_grad_dotdot || _need_dof_values_dotdot)
     {
       libmesh_assert(_sys.solutionUDotDot());
       _dof_values_dotdot.resize(n);
       _sys.solutionUDotDot()->get(_dof_indices, &_dof_values_dotdot[0]);
     }
     if (_need_u_dot_old || _need_dof_values_dot_old)
     {
       libmesh_assert(_sys.solutionUDotOld());
       _dof_values_dot_old.resize(n);
       _sys.solutionUDotOld()->get(_dof_indices, &_dof_values_dot_old[0]);
     }
     if (_need_u_dotdot_old || _need_dof_values_dotdot_old)
     {
       libmesh_assert(_sys.solutionUDotDotOld());
       _dof_values_dotdot_old.resize(n);
       _sys.solutionUDotDotOld()->get(_dof_indices, &_dof_values_dotdot_old[0]);
     }
   }
 
   if (_need_u_previous_nl || _need_grad_previous_nl || _need_second_previous_nl ||
       _need_dof_values_previous_nl)
   {
     _dof_values_previous_nl.resize(n);
     _sys.solutionPreviousNewton()->get(_dof_indices, &_dof_values_previous_nl[0]);
   }
 
   if (_sys.subproblem().safeAccessTaggedVectors())
   {
     auto & active_coupleable_vector_tags =
         _sys.subproblem().getActiveFEVariableCoupleableVectorTags(_tid);
     for (auto tag : active_coupleable_vector_tags)
       if (_need_vector_tag_u[tag] || _need_vector_tag_dof_u[tag])
         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 (_sys.subproblem().safeAccessTaggedMatrices())
   {
     auto & active_coupleable_matrix_tags =
         _sys.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 < _dof_indices.size(); 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();
   }
   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();
   }
 }

◆ fetchDoFValuesNeighbor()

void MooseVariableFE< Real >::fetchDoFValuesNeighbor ( )

inherited

Definition at line 2153 of file MooseVariableFE.C.

 {
   bool is_transient = _subproblem.isTransient();
 
   auto n = _dof_indices_neighbor.size();
   libmesh_assert(n);
 
   _dof_values_neighbor.resize(n);
   _sys.currentSolution()->get(_dof_indices_neighbor, &_dof_values_neighbor[0]);
 
   if (_need_u_previous_nl_neighbor || _need_grad_previous_nl_neighbor ||
       _need_second_previous_nl_neighbor || _need_dof_values_previous_nl_neighbor)
   {
     _dof_values_previous_nl_neighbor.resize(n);
     _sys.solutionPreviousNewton()->get(_dof_indices_neighbor, &_dof_values_previous_nl_neighbor[0]);
   }
 
   if (is_transient)
   {
     if (_need_u_old_neighbor || _need_grad_old_neighbor || _need_second_old_neighbor ||
         _need_dof_values_old_neighbor)
     {
       _dof_values_old_neighbor.resize(n);
       _sys.solutionOld().get(_dof_indices_neighbor, &_dof_values_old_neighbor[0]);
     }
     if (_need_u_older_neighbor || _need_grad_older_neighbor || _need_second_older_neighbor ||
         _need_dof_values_older_neighbor)
     {
       _dof_values_older_neighbor.resize(n);
       _sys.solutionOlder().get(_dof_indices_neighbor, &_dof_values_older_neighbor[0]);
     }
     if (_need_u_dot_neighbor || _need_grad_neighbor_dot || _need_dof_values_dot_neighbor)
     {
       _dof_values_dot_neighbor.resize(n);
       libmesh_assert(_sys.solutionUDot());
       for (unsigned int i = 0; i < n; i++)
         _dof_values_dot_neighbor[i] = (*_sys.solutionUDot())(_dof_indices_neighbor[i]);
     }
     if (_need_u_dotdot_neighbor || _need_grad_neighbor_dotdot || _need_dof_values_dotdot_neighbor)
     {
       _dof_values_dotdot_neighbor.resize(n);
       libmesh_assert(_sys.solutionUDotDot());
       for (unsigned int i = 0; i < n; i++)
         _dof_values_dotdot_neighbor[i] = (*_sys.solutionUDotDot())(_dof_indices_neighbor[i]);
     }
     if (_need_u_dot_old_neighbor || _need_dof_values_dot_old_neighbor)
     {
       _dof_values_dot_old_neighbor.resize(n);
       libmesh_assert(_sys.solutionUDotOld());
       for (unsigned int i = 0; i < n; i++)
         _dof_values_dot_old_neighbor[i] = (*_sys.solutionUDotOld())(_dof_indices_neighbor[i]);
     }
     if (_need_u_dotdot_old_neighbor || _need_dof_values_dotdot_old_neighbor)
     {
       _dof_values_dotdot_old_neighbor.resize(n);
       libmesh_assert(_sys.solutionUDotDotOld());
       for (unsigned int i = 0; i < n; i++)
         _dof_values_dotdot_old_neighbor[i] = (*_sys.solutionUDotDotOld())(_dof_indices_neighbor[i]);
     }
   }
   if (_need_du_dot_du_neighbor || _need_dof_du_dot_du_neighbor)
   {
     _dof_du_dot_du_neighbor.resize(n);
     for (decltype(n) i = 0; i < n; ++i)
       _dof_du_dot_du_neighbor[i] = _sys.duDotDu();
   }
   if (_need_du_dotdot_du_neighbor || _need_dof_du_dotdot_du_neighbor)
   {
     _dof_du_dotdot_du_neighbor.resize(n);
     for (decltype(n) i = 0; i < n; ++i)
       _dof_du_dotdot_du_neighbor[i] = _sys.duDotDotDu();
   }
 }

◆ feType()

const FEType& MooseVariableBase::feType ( ) const

inlineinherited

Get the type of finite element object.

Definition at line 48 of file MooseVariableBase.h.

Referenced by AuxiliarySystem::addVariable(), ADIntegratedBCTempl< T, compute_stage >::ADIntegratedBCTempl(), ADKernelTempl< T, compute_stage >::ADKernelTempl(), MortarConstraint::computeJacobian(), GapValueAux::computeValue(), DGKernelBase::DGKernelBase(), MultiAppNearestNodeTransfer::execute(), moose::internal::incompatVarMsg(), AdvancedOutput::initAvailableLists(), MultiAppProjectionTransfer::initialSetup(), AdvancedOutput::initShowHideLists(), IntegratedBC::IntegratedBC(), InterfaceKernel::InterfaceKernel(), Kernel::Kernel(), NodalBC::NodalBC(), NodalKernel::NodalKernel(), SolutionUserObject::pointValueWrapper(), MortarConstraint::reinit(), MultiAppCopyTransfer::transfer(), and VectorNodalBC::VectorNodalBC().

48 { return _fe_type; }

MooseVariableBase::_fe_type

FEType _fe_type

The FEType associated with this variable.

Definition: MooseVariableBase.h:105

◆ getDofIndices()

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

overridevirtualinherited

Implements MooseVariableFEBase.

Definition at line 476 of file MooseVariableFE.C.

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

◆ getElementalValue()

Number MooseVariableFE< Real >::getElementalValue	(	const Elem *	elem,
		unsigned int	idx = `0`
	)		const

overridevirtualinherited

Get the current value of this variable on an element.

Parameters

[in]	elem	Element at which to get value
[in]	idx	Local index of this variable's element DoFs

Returns: Variable value

Implements MooseVariableFEBase.

Definition at line 536 of file MooseVariableFE.C.

 {
   std::vector<dof_id_type> dof_indices;
   _dof_map.dof_indices(elem, dof_indices, _var_num);
 
   return (*_sys.currentSolution())(dof_indices[idx]);
 }

◆ getElementalValueOld()

Number MooseVariableFE< Real >::getElementalValueOld	(	const Elem *	elem,
		unsigned int	idx = `0`
	)		const

overridevirtualinherited

Get the old value of this variable on an element.

Parameters

[in]	elem	Element at which to get value
[in]	idx	Local index of this variable's element DoFs

Returns: Variable value

Implements MooseVariableFEBase.

Definition at line 546 of file MooseVariableFE.C.

 {
   std::vector<dof_id_type> dof_indices;
   _dof_map.dof_indices(elem, dof_indices, _var_num);
 
   return _sys.solutionOld()(dof_indices[idx]);
 }

◆ getElementalValueOlder()

Number MooseVariableFE< Real >::getElementalValueOlder	(	const Elem *	elem,
		unsigned int	idx = `0`
	)		const

overridevirtualinherited

Get the older value of this variable on an element.

Parameters

[in]	elem	Element at which to get value
[in]	idx	Local index of this variable's element DoFs

Returns: Variable value

Implements MooseVariableFEBase.

Definition at line 556 of file MooseVariableFE.C.

 {
   std::vector<dof_id_type> dof_indices;
   _dof_map.dof_indices(elem, dof_indices, _var_num);
 
   return _sys.solutionOlder()(dof_indices[idx]);
 }

◆ getGradient()

OutputTools< Real >::OutputGradient MooseVariableFE< Real >::getGradient	(	const Elem *	elem,
		const std::vector< std::vector< typename OutputTools< Real >::OutputGradient >> &	grad_phi
	)		const

inherited

Compute the variable gradient value at a point on an element.

Parameters

elem	The element we are computing on
phi	Evaluated shape functions at a point

Returns: The variable gradient value

Definition at line 1568 of file MooseVariableFE.C.

 {
   std::vector<dof_id_type> dof_indices;
   _dof_map.dof_indices(elem, dof_indices, _var_num);
 
   typename OutputTools<OutputType>::OutputGradient value;
   if (isNodal())
   {
     for (unsigned int i = 0; i < dof_indices.size(); ++i)
     {
       // The zero index is because we only have one point that the phis are evaluated at
       value += grad_phi[i][0] * (*_sys.currentSolution())(dof_indices[i]);
     }
   }
   else
   {
     mooseAssert(dof_indices.size() == 1, "Wrong size for dof indices");
     value = 0.0;
   }
 
   return value;
 }

◆ getNodalValue()

Number MooseVariableFE< Real >::getNodalValue ( const Node & node )

overridevirtualinherited

Get the value of this variable at given node.

Implements MooseVariableFEBase.

Definition at line 484 of file MooseVariableFE.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);
 
   return (*_sys.currentSolution())(dof);
 }

◆ getNodalValueOld()

Number MooseVariableFE< Real >::getNodalValueOld ( const Node & node )

overridevirtualinherited

Get the old value of this variable at given node.

Implements MooseVariableFEBase.

Definition at line 502 of file MooseVariableFE.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);
   return _sys.solutionOld()(dof);
 }

◆ getNodalValueOlder()

Number MooseVariableFE< Real >::getNodalValueOlder ( const Node & node )

overridevirtualinherited

Get the t-2 value of this variable at given node.

Implements MooseVariableFEBase.

Definition at line 519 of file MooseVariableFE.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);
   return _sys.solutionOlder()(dof);
 }

◆ getValue()

Real MooseVariableFE< Real >::getValue	(	const Elem *	elem,
		const std::vector< std::vector< Real >> &	phi
	)		const

inherited

Compute the variable value at a point on an element.

Parameters

elem	The element we are computing on
phi	Evaluated shape functions at a point

Returns: The variable value

Definition at line 876 of file MooseVariableFE.C.

 {
   std::vector<dof_id_type> dof_indices;
   _dof_map.dof_indices(elem, dof_indices, _var_num);
 
   OutputType value = 0;
   if (isNodal())
   {
     for (unsigned int i = 0; i < dof_indices.size(); ++i)
     {
       // The zero index is because we only have one point that the phis are evaluated at
       value += phi[i][0] * (*_sys.currentSolution())(dof_indices[i]);
     }
   }
   else
   {
     mooseAssert(dof_indices.size() == 1, "Wrong size for dof indices");
     value = (*_sys.currentSolution())(dof_indices[0]);
   }
 
   return value;
 }

◆ gradPhi()

const FieldVariablePhiGradient& MooseVariableFE< Real >::gradPhi ( )

inlineinherited

Definition at line 165 of file MooseVariableFE.h.

165 { return _grad_phi; }

MooseVariableFE< Real >::_grad_phi

const FieldVariablePhiGradient & _grad_phi

Definition: MooseVariableFE.h:950

◆ gradPhiFace()

const FieldVariablePhiGradient& MooseVariableFE< Real >::gradPhiFace ( )

inlineinherited

Definition at line 170 of file MooseVariableFE.h.

170 { return _grad_phi_face; }

MooseVariableFE< Real >::_grad_phi_face

const FieldVariablePhiGradient & _grad_phi_face

Definition: MooseVariableFE.h:956

◆ gradPhiFaceNeighbor()

const FieldVariablePhiGradient& MooseVariableFE< Real >::gradPhiFaceNeighbor ( )

inlineinherited

Definition at line 180 of file MooseVariableFE.h.

180 { return _grad_phi_face_neighbor; }

MooseVariableFE< Real >::_grad_phi_face_neighbor

const FieldVariablePhiGradient & _grad_phi_face_neighbor

Definition: MooseVariableFE.h:968

◆ gradPhiNeighbor()

const FieldVariablePhiGradient& MooseVariableFE< Real >::gradPhiNeighbor ( )

inlineinherited

Definition at line 175 of file MooseVariableFE.h.

175 { return _grad_phi_neighbor; }

MooseVariableFE< Real >::_grad_phi_neighbor

const FieldVariablePhiGradient & _grad_phi_neighbor

Definition: MooseVariableFE.h:962

◆ gradSln()

const FieldVariableGradient& MooseVariableFE< Real >::gradSln ( )

inlineinherited

Definition at line 225 of file MooseVariableFE.h.

225 { return _grad_u; }

MooseVariableFE< Real >::_grad_u

FieldVariableGradient _grad_u

Definition: MooseVariableFE.h:984

◆ gradSlnDot()

const FieldVariableGradient& MooseVariableFE< Real >::gradSlnDot ( )

inlineinherited

Definition at line 241 of file MooseVariableFE.h.

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

const FieldVariableGradient& MooseVariableFE< Real >::gradSlnDotDot ( )

inlineinherited

Definition at line 252 of file MooseVariableFE.h.

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

◆ gradSlnNeighbor()

const FieldVariableGradient& MooseVariableFE< Real >::gradSlnNeighbor ( )

inlineinherited

Definition at line 452 of file MooseVariableFE.h.

452 { return _grad_u_neighbor; }

MooseVariableFE< Real >::_grad_u_neighbor

FieldVariableGradient _grad_u_neighbor

Definition: MooseVariableFE.h:1016

◆ gradSlnNeighborDot()

const FieldVariableGradient& MooseVariableFE< Real >::gradSlnNeighborDot ( )

inlineinherited

Definition at line 468 of file MooseVariableFE.h.

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

◆ gradSlnNeighborDotDot()

const FieldVariableGradient& MooseVariableFE< Real >::gradSlnNeighborDotDot ( )

inlineinherited

Definition at line 479 of file MooseVariableFE.h.

   {
     if (_sys.solutionUDotDot())
     {
       _need_grad_neighbor_dotdot = true;
       return _grad_u_neighbor_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`.");
   }

◆ gradSlnOld()

const FieldVariableGradient& MooseVariableFE< Real >::gradSlnOld ( )

inlineinherited

Definition at line 226 of file MooseVariableFE.h.

   {
     _need_grad_old = true;
     return _grad_u_old;
   }

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MooseVariableConstMonomial()

Member Function Documentation

◆ activeOnSubdomain()

◆ activeSubdomains()

◆ add()

◆ adDofValues()

◆ adGradPhi()

◆ adGradPhiFace()

◆ adGradSln()

◆ adGradSlnNeighbor()

◆ adNodalValue()

◆ adSecondSln()

◆ adSecondSlnNeighbor()

◆ adSln()

◆ adSlnNeighbor()

◆ adUDot()

◆ adUDotNeighbor()

◆ allDofIndices()

◆ assignADNodalValue()

◆ assignNodalValue()

◆ assignNodalValueNeighbor()

◆ clearDofIndices()

◆ computeAD()

◆ computeADNeighbor()

◆ computeElemValues()

◆ computeElemValuesFace()

◆ computeIncrementAtNode()

◆ computeIncrementAtQps()

◆ computeMonomialNeighborValuesHelper()

◆ computeMonomialValuesHelper()

◆ computeNeighborValues()

◆ computeNeighborValuesFace()

◆ computeNeighborValuesHelper()

◆ computeNodalNeighborValues()

◆ computeNodalValues()

◆ computeValuesHelper()

◆ computingCurl()

◆ computingSecond()

◆ curlPhi()

◆ curlPhiFace()

◆ curlPhiFaceNeighbor()

◆ curlPhiNeighbor()

◆ curlSln()

◆ curlSlnNeighbor()

◆ curlSlnOld()

◆ curlSlnOlder()

◆ curlSlnOlderNeighbor()

◆ curlSlnOldNeighbor()

◆ currentElem()

◆ currentSide()

◆ dofIndices() [1/2]

◆ dofIndices() [2/2]

◆ dofIndicesNeighbor()

◆ dofMap()

◆ dofValue()

◆ dofValues()

◆ dofValuesDot()

◆ dofValuesDotDot()

◆ dofValuesDotDotNeighbor()

◆ dofValuesDotDotOld()

◆ dofValuesDotDotOldNeighbor()

◆ dofValuesDotNeighbor()

◆ dofValuesDotOld()

◆ dofValuesDotOldNeighbor()

◆ dofValuesDuDotDotDu()

◆ dofValuesDuDotDotDuNeighbor()

◆ dofValuesDuDotDu()

◆ dofValuesDuDotDuNeighbor()

◆ dofValuesNeighbor()

◆ dofValuesOld()

◆ dofValuesOlder()

◆ dofValuesOlderNeighbor()

◆ dofValuesOldNeighbor()

◆ dofValuesPreviousNL()

◆ dofValuesPreviousNLNeighbor()

◆ duDotDotDu()