#include <MooseVariableDataFV.h>

Inheritance diagram for MooseVariableDataFV< OutputType >:

Public Types
typedef libMesh::TensorTools::IncrementRank< OutputType >::type	OutputGradient

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

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

typedef MooseArray< OutputType >	FieldVariableValue

typedef MooseArray< OutputGradient >	FieldVariableGradient

typedef MooseArray< OutputSecond >	FieldVariableSecond

typedef MooseArray< OutputType >	FieldVariableCurl

typedef MooseArray< OutputDivergence >	FieldVariableDivergence

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

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

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

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

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

typedef MooseArray< OutputData >	DofValue

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

typedef MooseArray< DofValue >	DofValues

typedef MooseArray< ADDofValue >	ADDofValues

Public Member Functions
	MooseVariableDataFV (const MooseVariableFV< OutputType > &var, SystemBase &sys, THREAD_ID tid, Moose::ElementType element_type, const Elem *const &elem)

bool	isNodal () const override

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

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

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

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

void	computeValuesFace (const FaceInfo &fi)
	compute the variable values

void	computeValues ()
	compute the variable values

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

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

void	prepareIC ()
	prepare the initial condition

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

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

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

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

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

const ADTemplateVariableValue< OutputType > &	adSln () const

const ADTemplateVariableGradient< OutputType > &	adGradSln () const

const ADTemplateVariableGradient< OutputType > &	adGradSlnDot () const

const ADTemplateVariableSecond< OutputType > &	adSecondSln () const

const ADTemplateVariableValue< OutputType > &	adUDot () const

const ADTemplateVariableValue< OutputType > &	adUDotDot () const

const FieldVariableValue &	uDot () const

const FieldVariableValue &	uDotDot () const

const FieldVariableValue &	uDotOld () const

const FieldVariableValue &	uDotDotOld () const

const VariableValue &	duDotDu () const

const VariableValue &	duDotDotDu () const

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

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

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

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

unsigned int	numberOfDofs () const

void	clearDofIndices ()

const DofValue &	dofValuesDot () const

const DofValue &	dofValuesDotOld () const

const DofValue &	dofValuesDotDot () const

const DofValue &	dofValuesDotDotOld () const

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

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

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

const MooseArray< ADReal > &	adDofValuesDot () const
	Return the AD dof time derivatives.

const FieldVariableValue &	increment () const
	Increment getter.

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

bool	hasDirichletBC () const
	checks if a Dirichlet BC exists on this face

void	meshChanged () override
	Called on this object when the mesh changes.

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

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

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

void	setNodalValue (const RealVectorValue &value)

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

void	insert (NumericVector< Number > &residual)

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

void	add (NumericVector< Number > &residual)

const DofValues &	dofValues () const

const DofValues &	dofValuesOld () const

const DofValues &	dofValuesOlder () const

const DofValues &	dofValuesPreviousNL () const

const OutputType &	nodalValue (Moose::SolutionState state) const

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

const FieldVariableValue &	vectorTagValue (TagID tag) const

const FieldVariableGradient &	vectorTagGradient (TagID tag) const

const FieldVariableValue &	matrixTagValue (TagID tag) const

const DofValues &	nodalVectorTagValue (TagID tag) const

const DofValues &	nodalMatrixTagValue (TagID tag) const

const DofValues &	vectorTagDofValue (TagID tag) const

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

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

void	prepareAux ()
	Clear aux state.

void	sizeMatrixTagData ()
	size matrix tag data


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

Static Public Member Functions
static InputParameters	validParams ()

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

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

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

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

void	fetchDofValues ()

void	fetchDofValues ()

void	zeroSizeDofValues ()

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

void	assignNodalValue ()

void	assignNodalValue ()

void	assignNodalValue ()

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

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

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

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

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

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

unsigned int	_count
	Number of components of the associated variable.

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

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

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

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

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

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

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

std::vector< bool >	_need_vector_tag_dof_u

std::vector< bool >	_need_matrix_tag_dof_u

std::vector< DofValues >	_vector_tags_dof_u

std::vector< DofValues >	_matrix_tags_dof_u

std::vector< FieldVariableValue >	_vector_tag_u

std::vector< bool >	_need_vector_tag_u

std::vector< FieldVariableGradient >	_vector_tag_grad

std::vector< bool >	_need_vector_tag_grad

std::vector< FieldVariableValue >	_matrix_tag_u

std::vector< bool >	_need_matrix_tag_u

OutputType	_nodal_value
	Nodal values.

OutputType	_nodal_value_old

OutputType	_nodal_value_older

OutputType	_nodal_value_previous_nl

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

MooseArray< OutputType >	_nodal_value_old_array

MooseArray< OutputType >	_nodal_value_older_array

bool	_need_u_dot
	u dot flags

bool	_need_u_dotdot

bool	_need_u_dot_old

bool	_need_u_dotdot_old

bool	_need_du_dot_du

bool	_need_du_dotdot_du

bool	_need_grad_dot
	gradient dot flags

bool	_need_grad_dotdot

bool	_need_dof_values_dot
	local solution flags

bool	_need_dof_values_dotdot

bool	_need_dof_values_dot_old

bool	_need_dof_values_dotdot_old

bool	_need_dof_du_dot_du

bool	_need_dof_du_dotdot_du

DofValues	_dof_values_dot
	time derivative of the solution values

DofValues	_dof_values_dotdot
	second time derivative of the solution values

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

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

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

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

OutputType	_nodal_value_dot
	nodal values of u_dot

OutputType	_nodal_value_dotdot
	nodal values of u_dotdot

OutputType	_nodal_value_dot_old
	nodal values of u_dot_old

OutputType	_nodal_value_dotdot_old
	nodal values of u_dotdot_old

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

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

FEProblemBase &	_mci_feproblem
	Reference to FEProblemBase instance.

Private Member Functions
void	initializeSolnVars ()

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

bool	safeToComputeADUDot () const
	Helper method that tells us whether it's safe to compute _ad_u_dot.

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

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

const libMesh::FEType &	_fe_type

const unsigned int	_var_num

const Assembly &	_assembly

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

libMesh::FEContinuity	_continuity
	Continuity type of the variable.

FieldVariableValue	_increment
	Increment in the variable used in dampers.

const ADReal	_ad_zero
	A zero AD variable.

bool	_need_second
	SolutionState second_u flags.

bool	_need_second_old

bool	_need_second_older

bool	_need_second_previous_nl

bool	_need_curl
	curl flags

bool	_need_curl_old

bool	_need_curl_older

bool	_need_ad
	AD flags.

bool	_need_ad_u

bool	_need_ad_u_dot

bool	_need_ad_u_dotdot

bool	_need_ad_grad_u

bool	_need_ad_grad_u_dot

bool	_need_ad_second_u

FieldVariableGradient	_grad_u_dot
	grad_u dots

FieldVariableGradient	_grad_u_dotdot

FieldVariableSecond	_second_u
	second_u

FieldVariableSecond	_second_u_old

FieldVariableSecond	_second_u_older

FieldVariableSecond	_second_u_previous_nl

FieldVariableCurl	_curl_u
	curl_u

FieldVariableCurl	_curl_u_old

FieldVariableCurl	_curl_u_older

ADTemplateVariableValue< OutputShape >	_ad_u
	AD u.

ADTemplateVariableGradient< OutputShape >	_ad_grad_u

ADTemplateVariableSecond< OutputShape >	_ad_second_u

MooseArray< ADReal >	_ad_dof_values

MooseArray< ADReal >	_ad_dofs_dot

MooseArray< ADReal >	_ad_dofs_dotdot

ADTemplateVariableValue< OutputShape >	_ad_u_dot

ADTemplateVariableValue< OutputShape >	_ad_u_dotdot

ADTemplateVariableGradient< OutputShape >	_ad_grad_u_dot

FieldVariableValue	_u_dot
	u_dot (time derivative)

FieldVariableValue	_u_dotdot
	u_dotdot (second time derivative)

FieldVariableValue	_u_dot_old
	u_dot_old (time derivative)

FieldVariableValue	_u_dotdot_old
	u_dotdot_old (second time derivative)

VariableValue	_du_dot_du
	derivative of u_dot wrt u

VariableValue	_du_dotdot_du
	derivative of u_dotdot wrt u

const TimeIntegrator *const	_time_integrator
	Pointer to time integrator.

const Elem *const &	_elem
	The current elem.

const Elem *	_prev_elem = nullptr
	used to keep track of when dof indices are out of date

bool	_has_dirichlet_bc
	if this variable has a dirichlet bc defined on a particular face

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

const libMesh::QBase *	_qrule
	The quadrature rule.

ADReal	_ad_real_dummy = 0
	A dummy ADReal variable.

TheWarehouse::QueryCache	_fv_elemental_kernel_query_cache
	Cached warehouse query for FVElementalKernels.

TheWarehouse::QueryCache	_fv_flux_kernel_query_cache
	Cached warehouse query for FVFluxKernels.

Friends
void	Moose::initDofIndices (MooseVariableDataFV< OutputType > &, const Elem &)

Detailed Description

template<typename OutputType>
class MooseVariableDataFV< OutputType >

Definition at line 69 of file MooseVariableDataFV.h.

Member Typedef Documentation

◆ ADDofValue

template<typename OutputType >

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

inherited

Definition at line 47 of file MooseVariableDataBase.h.

◆ ADDofValues

template<typename OutputType >

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

inherited

Definition at line 49 of file MooseVariableDataBase.h.

◆ DofValue

template<typename OutputType >

typedef MooseArray<OutputData> MooseVariableDataFV< OutputType >::DofValue

Definition at line 94 of file MooseVariableDataFV.h.

◆ DofValues

template<typename OutputType >

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

inherited

Definition at line 48 of file MooseVariableDataBase.h.

◆ FieldVariableCurl

template<typename OutputType >

typedef MooseArray<OutputType> MooseVariableDataFV< OutputType >::FieldVariableCurl

Definition at line 81 of file MooseVariableDataFV.h.

◆ FieldVariableDivergence

template<typename OutputType >

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

Definition at line 82 of file MooseVariableDataFV.h.

◆ FieldVariableGradient

template<typename OutputType >

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

Definition at line 79 of file MooseVariableDataFV.h.

◆ FieldVariableSecond

template<typename OutputType >

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

Definition at line 80 of file MooseVariableDataFV.h.

◆ FieldVariableValue

template<typename OutputType >

typedef MooseArray<OutputType> MooseVariableDataFV< OutputType >::FieldVariableValue

Definition at line 78 of file MooseVariableDataFV.h.

◆ OutputData

template<typename OutputType >

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

Definition at line 93 of file MooseVariableDataFV.h.

◆ OutputDivergence

template<typename OutputType >

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

Definition at line 75 of file MooseVariableDataFV.h.

◆ OutputGradient

template<typename OutputType >

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

Definition at line 73 of file MooseVariableDataFV.h.

◆ OutputSecond

template<typename OutputType >

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

Definition at line 74 of file MooseVariableDataFV.h.

◆ OutputShape

template<typename OutputType >

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

Definition at line 85 of file MooseVariableDataFV.h.

◆ OutputShapeDivergence

template<typename OutputType >

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

Definition at line 90 of file MooseVariableDataFV.h.

◆ OutputShapeGradient

template<typename OutputType >

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

Definition at line 88 of file MooseVariableDataFV.h.

◆ OutputShapeSecond

template<typename OutputType >

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

Definition at line 89 of file MooseVariableDataFV.h.

Constructor & Destructor Documentation

◆ MooseVariableDataFV()

template<typename OutputType >

MooseVariableDataFV< OutputType >::MooseVariableDataFV	(	const MooseVariableFV< OutputType > &	var,
		SystemBase &	sys,
		THREAD_ID	tid,
		Moose::ElementType	element_type,
		const Elem *const &	elem
	)

Definition at line 31 of file MooseVariableDataFV.C.

  : MooseVariableDataBase<OutputType>(var, sys, tid),
    MeshChangedInterface(var.parameters()),
    _var(var),
    _fe_type(_var.feType()),
    _var_num(_var.number()),
    _assembly(_subproblem.assembly(_tid, var.kind() == Moose::VAR_SOLVER ? sys.number() : 0)),
    _element_type(element_type),
    _ad_zero(0),
    _need_second(false),
    _need_second_old(false),
    _need_second_older(false),
    _need_second_previous_nl(false),
    _need_curl(false),
    _need_curl_old(false),
    _need_curl_older(false),
    // for FV variables, they use each other's ad_u values to compute ghost cell
    // values - we don't have any way to propagate these inter-variable-data
    // dependencies. So if something needs an ad_u value, that need isn't
    // propagated through to both the element and the neighbor
    // data structures. So instead just set _need_ad+_need_ad_u values to true always.
    _need_ad(true),
    _need_ad_u(true),
    _need_ad_u_dot(false),
    _need_ad_u_dotdot(false),
    _need_ad_grad_u(false),
    _need_ad_grad_u_dot(false),
    _need_ad_second_u(false),
    _time_integrator(_sys.queryTimeIntegrator(_var_num)),
    _elem(elem),
    _displaced(dynamic_cast<const DisplacedSystem *>(&_sys) ? true : false),
    _qrule(nullptr)
{
  _fv_elemental_kernel_query_cache =
      _subproblem.getMooseApp().theWarehouse().query().template condition<AttribSystem>(
          "FVElementalKernel");
  _fv_flux_kernel_query_cache =
      _subproblem.getMooseApp().theWarehouse().query().template condition<AttribSystem>(
          "FVFluxKernel");
}

Member Function Documentation

◆ add() [1/2]

template<typename OutputType >

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

inherited

Add the current local DOF values to the input vector.

Definition at line 468 of file MooseVariableDataBase.C.

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

◆ add() [2/2]

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

inherited

Definition at line 479 of file MooseVariableDataBase.C.

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

◆ adDofValues()

template<typename OutputType >

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

Return the AD dof values.

Definition at line 786 of file MooseVariableDataFV.C.

{
  _var.requireQpComputations();
  _need_ad = true;
  return _ad_dof_values;
}

◆ adDofValuesDot()

template<typename OutputType >

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

Return the AD dof time derivatives.

Definition at line 795 of file MooseVariableDataFV.C.

{
  _var.requireQpComputations();
  _need_ad = _need_ad_u_dot = true;
  return _ad_dofs_dot;
}

◆ adGradSln()

template<typename OutputType >

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

Returns: The automatic differentiation gradient indexable at quadrature points

Definition at line 813 of file MooseVariableDataFV.C.

{
  _var.requireQpComputations();
  _need_ad = _need_ad_grad_u = true;
  return _ad_grad_u;
}

◆ adGradSlnDot()

template<typename OutputType >

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

inline

Definition at line 185 of file MooseVariableDataFV.h.

  {
    mooseError("Gradient of time derivative not yet implemented for FV");
  }

◆ adSecondSln()

template<typename OutputType >

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

Returns: The automatic differentiation matrix of second derivatives indexable at quadrature points

Definition at line 822 of file MooseVariableDataFV.C.

{
  _var.requireQpComputations();
  _need_ad = _need_ad_second_u = true;
  return _ad_second_u;
}

◆ adSln()

template<typename OutputType >

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

Returns: The automatic differentiation solution indexable at quadrature points

Definition at line 804 of file MooseVariableDataFV.C.

{
  _var.requireQpComputations();
  _need_ad = _need_ad_u = true;
  return _ad_u;
}

◆ adUDot()

template<typename OutputType >

const ADTemplateVariableValue< OutputType > & MooseVariableDataFV< OutputType >::adUDot ( ) const

inline

Definition at line 831 of file MooseVariableDataFV.C.

{
  _var.requireQpComputations();
 
  _need_ad = _need_ad_u_dot = true;
 
  if (!safeToComputeADUDot())
    // We will just copy the value of _u_dot into _ad_u_dot
    _need_u_dot = true;
 
  return _ad_u_dot;
}

◆ adUDotDot()

template<typename OutputType >

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

Definition at line 486 of file MooseVariableDataFV.h.

{
  // Generally speaking, we need u dot information when computing u dot dot
  adUDot();
 
  _need_ad = _need_ad_u_dotdot = true;
 
  if (!safeToComputeADUDot())
    // We will just copy the value of _u_dotdot into _ad_u_dotdot
    _need_u_dotdot = true;
 
  return _ad_u_dotdot;
}

◆ assignNodalValue() [1/3]

template<typename OutputType >

void MooseVariableDataBase< OutputType >::assignNodalValue ( )

protectedinherited

Definition at line 763 of file MooseVariableDataBase.C.

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

◆ assignNodalValue() [2/3]

void MooseVariableDataBase< RealVectorValue >::assignNodalValue ( )

protectedinherited

◆ assignNodalValue() [3/3]

void MooseVariableDataBase< RealVectorValue >::assignNodalValue ( )

protectedinherited

Definition at line 799 of file MooseVariableDataBase.C.

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

◆ clearDofIndices()

template<typename OutputType >

void MooseVariableDataFV< OutputType >::clearDofIndices ( )

inline

Definition at line 240 of file MooseVariableDataFV.h.

  {
    _dof_indices.clear();
    _prev_elem = nullptr;
  }

◆ computeAD()

template<typename OutputType >

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

compute AD things

Definition at line 511 of file MooseVariableDataFV.C.

{
  // This query and if check prevent running this code when we have FV
  // variables, but no kernels.  When this happens, maxVarNDofsPerElem is
  // not computed (because no kernels) and is zero giving nonsense offsets for
  // AD stuff.  So we just skip all this when that is the case.  Maybe there
  // is a better way to do this - like just checking if getMaxVarNDofsPerElem
  // returns zero?
  std::vector<FVKernel *> ks;
  _fv_elemental_kernel_query_cache.queryInto(ks);
  if (ks.size() == 0)
  {
    _fv_flux_kernel_query_cache.queryInto(ks);
    if (ks.size() == 0)
      return;
  }
 
  _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);
  }
 
  if (_need_ad_u_dotdot)
  {
    _ad_dofs_dotdot.resize(num_dofs);
    _ad_u_dotdot.resize(nqp);
  }
 
  if (_need_ad_second_u)
    assignForAllQps(0, _ad_second_u, nqp);
 
  if (_need_ad_u_dot)
    assignForAllQps(_ad_zero, _ad_u_dot, nqp);
 
  if (_need_ad_u_dotdot)
    assignForAllQps(_ad_zero, _ad_u_dotdot, nqp);
 
  const bool do_derivatives =
      ADReal::do_derivatives && _sys.number() == _subproblem.currentNlSysNum();
 
  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 (do_derivatives)
      Moose::derivInsert(_ad_dof_values[i].derivatives(), _dof_indices[i], 1.);
 
    if (_need_ad_u_dot && safeToComputeADUDot() && _time_integrator->dt())
    {
      _ad_dofs_dot[i] = _ad_dof_values[i];
      _time_integrator->computeADTimeDerivatives(_ad_dofs_dot[i],
                                                 _dof_indices[i],
                                                 _need_ad_u_dotdot ? _ad_dofs_dotdot[i]
                                                                   : _ad_real_dummy);
    }
  }
 
  if (_need_ad_u)
    assignForAllQps(_ad_dof_values[0], _ad_u, nqp);
 
  if (_need_ad_grad_u)
    assignForAllQps(
        cast_ref<const MooseVariableFV<OutputType> &>(_var).adGradSln(_elem, Moose::currentState()),
        _ad_grad_u,
        nqp);
 
  if (_need_ad_u_dot)
  {
    if (safeToComputeADUDot())
    {
      assignForAllQps(_ad_dofs_dot[0], _ad_u_dot, nqp);
      if (_need_ad_u_dotdot)
        assignForAllQps(_ad_dofs_dotdot[0], _ad_u_dotdot, nqp);
    }
    else
    {
      assignForAllQps(_u_dot[0], _ad_u_dot, nqp);
      if (_need_ad_u_dotdot)
        assignForAllQps(_u_dotdot[0], _ad_u_dotdot, nqp);
    }
  }
}

◆ computeIncrementAtQps()

template<typename OutputType >

void MooseVariableDataFV< OutputType >::computeIncrementAtQps ( const libMesh::NumericVector< libMesh::Number > & increment_vec )

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

◆ computeValues()

template<typename OutputType >

void MooseVariableDataFV< OutputType >::computeValues ( )

compute the variable values

Definition at line 420 of file MooseVariableDataFV.C.

{
  initDofIndices();
  initializeSolnVars();
 
  unsigned int num_dofs = _dof_indices.size();
 
  if (num_dofs > 0)
    fetchDofValues();
  else
    // We don't have any dofs. There's nothing to do
    return;
 
  mooseAssert(num_dofs == 1 && _vector_tags_dof_u[_solution_tag].size() == 1,
              "There should only be one dof per elem for FV variables");
 
  bool is_transient = _subproblem.isTransient();
  const auto nqp = _qrule->n_points();
  auto && active_coupleable_matrix_tags =
      _sys.subproblem().getActiveFEVariableCoupleableMatrixTags(_tid);
 
  bool second_required =
      _need_second || _need_second_old || _need_second_older || _need_second_previous_nl;
  bool curl_required = _need_curl || _need_curl_old;
 
  for (const auto qp : make_range(nqp))
  {
    if (is_transient)
    {
      if (_need_u_dot)
        _u_dot[qp] = _dof_values_dot[0];
 
      if (_need_u_dotdot)
        _u_dotdot[qp] = _dof_values_dotdot[0];
 
      if (_need_u_dot_old)
        _u_dot_old[qp] = _dof_values_dot_old[0];
 
      if (_need_u_dotdot_old)
        _u_dotdot_old[qp] = _dof_values_dotdot_old[0];
 
      if (_need_du_dot_du)
        _du_dot_du[qp] = _dof_du_dot_du[0];
 
      if (_need_du_dotdot_du)
        _du_dotdot_du[qp] = _dof_du_dotdot_du[0];
    }
 
    if (second_required)
    {
      if (_need_second)
        _second_u[qp] = 0.;
 
      if (_need_second_previous_nl)
        _second_u_previous_nl[qp] = 0.;
 
      if (is_transient)
      {
        if (_need_second_old)
          _second_u_old[qp] = 0.;
 
        if (_need_second_older)
          _second_u_older[qp] = 0.;
      }
    }
 
    if (curl_required)
    {
      if (_need_curl)
        _curl_u[qp] = 0.;
 
      if (is_transient && _need_curl_old)
        _curl_u_old[qp] = 0.;
    }
 
    for (auto tag : _required_vector_tags)
      if (_need_vector_tag_u[tag])
        _vector_tag_u[tag][qp] = _vector_tags_dof_u[tag][0];
 
    for (auto tag : active_coupleable_matrix_tags)
      if (_need_matrix_tag_u[tag])
        _matrix_tag_u[tag][qp] = _matrix_tags_dof_u[tag][0];
  }
 
  // Automatic differentiation
  if (_need_ad)
    computeAD(num_dofs, nqp);
}

◆ computeValuesFace()

template<typename OutputType >

void MooseVariableDataFV< OutputType >::computeValuesFace ( const FaceInfo & fi )

compute the variable values

Definition at line 381 of file MooseVariableDataFV.C.

{
  _has_dirichlet_bc = false;
  _dof_map.dof_indices(_elem, _dof_indices, _var_num);
 
  // TODO: compute reconstructed values somehow.  For now, just do the trivial
  // reconstruction where we take the const cell value from the centroid and
  // use that value on the face.  How will users affect the reconstruction
  // method used here?  After reconstruction, we should cache the computed
  // soln/gradients per element so we don't have to recompute them again for
  // other faces that share an element with this face.
  //
  // TODO: Also we need to be able to track (AD) derivatives through the
  // reconstruction process - how will we do that?
 
  computeValues();
 
  // TODO: maybe initialize a separate _grad_u_interface here that is
  // only used for diffusion terms that need an interface gradient.  Also -
  // it would need cross-diffusion corrections for non-orthogonal meshes
  // eventually. Or maybe we just leave this alone zero and have users
  // calculate whatever grad_interface value they want and provide some
  // helper functions for cross-diffusion correction.
 
  // TODO: figure out how to store old/older values of reconstructed
  // solutions/gradient states without having to re-reconstruct them from
  // older dof/soln values.
}

◆ curlSln()

template<typename OutputType >

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

Local solution curl getter.

Parameters

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

Definition at line 240 of file MooseVariableDataFV.C.

{
  _var.requireQpComputations();
  switch (state)
  {
    case Moose::Current:
    {
      _need_curl = true;
      return _curl_u;
    }
 
    case Moose::Old:
    {
      _need_curl_old = true;
      return _curl_u_old;
    }
 
    case Moose::Older:
    {
      _need_curl_older = true;
      return _curl_u_older;
    }
 
    default:
      mooseError("We don't currently support curl from the previous non-linear iteration");
  }
}

◆ currentElem()

template<typename OutputType >

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

inline

The current element.

Definition at line 139 of file MooseVariableDataFV.h.

139{ return _elem; }

◆ dofIndices()

template<typename OutputType >

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

Definition at line 502 of file MooseVariableDataFV.h.

{
  return const_cast<MooseVariableDataFV<OutputType> *>(this)->initDofIndices();
}

◆ dofValues()

template<typename OutputType >

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

inherited

Definition at line 354 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Current);
}

◆ dofValuesDot()

template<typename OutputType >

const MooseVariableDataFV< OutputType >::DofValue & MooseVariableDataFV< OutputType >::dofValuesDot ( ) const

Definition at line 669 of file MooseVariableDataFV.C.

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

◆ dofValuesDotDot()

template<typename OutputType >

const MooseVariableDataFV< OutputType >::DofValue & MooseVariableDataFV< OutputType >::dofValuesDotDot ( ) const

Definition at line 684 of file MooseVariableDataFV.C.

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

◆ dofValuesDotDotOld()

template<typename OutputType >

const MooseVariableDataFV< OutputType >::DofValue & MooseVariableDataFV< OutputType >::dofValuesDotDotOld ( ) const

Definition at line 715 of file MooseVariableDataFV.C.

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

◆ dofValuesDotOld()

template<typename OutputType >

const MooseVariableDataFV< OutputType >::DofValue & MooseVariableDataFV< OutputType >::dofValuesDotOld ( ) const

Definition at line 700 of file MooseVariableDataFV.C.

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

◆ dofValuesDuDotDotDu()

template<typename OutputType >

const MooseArray< Number > & MooseVariableDataFV< OutputType >::dofValuesDuDotDotDu ( ) const

Definition at line 739 of file MooseVariableDataFV.C.

{
  _need_dof_du_dotdot_du = true;
  return _dof_du_dotdot_du;
}

◆ dofValuesDuDotDu()

template<typename OutputType >

const MooseArray< Number > & MooseVariableDataFV< OutputType >::dofValuesDuDotDu ( ) const

Definition at line 731 of file MooseVariableDataFV.C.

{
  _need_dof_du_dot_du = true;
  return _dof_du_dot_du;
}

◆ dofValuesOld()

template<typename OutputType >

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

inherited

Definition at line 361 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Old);
}

◆ dofValuesOlder()

template<typename OutputType >

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

inherited

Definition at line 368 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Older);
}

◆ dofValuesPreviousNL()

template<typename OutputType >

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

inherited

Definition at line 375 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::PreviousNL);
}

◆ duDotDotDu()

template<typename OutputType >

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

inline

Definition at line 214 of file MooseVariableDataFV.h.

  {
    _need_du_dotdot_du = true;
    return _du_dotdot_du;
  }

◆ duDotDu()

template<typename OutputType >

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

inline

Definition at line 208 of file MooseVariableDataFV.h.

  {
    _need_du_dot_du = true;
    return _du_dot_du;
  }

◆ fetchADDofValues()

template<typename OutputType >

void MooseVariableDataFV< OutputType >::fetchADDofValues ( )

private

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

These methods are only truly meaningful for nodal basis families

Definition at line 747 of file MooseVariableDataFV.C.

{
  auto n = _dof_indices.size();
  libmesh_assert(n);
  _ad_dof_values.resize(n);
 
  const bool do_derivatives =
      ADReal::do_derivatives && _sys.number() == _subproblem.currentNlSysNum();
 
  for (decltype(n) i = 0; i < n; ++i)
  {
    _ad_dof_values[i] = _vector_tags_dof_u[_solution_tag][i];
    if (do_derivatives)
      Moose::derivInsert(_ad_dof_values[i].derivatives(), _dof_indices[i], 1.);
  }
}

◆ fetchDofValues() [1/3]

template<typename OutputType >

void MooseVariableDataBase< OutputType >::fetchDofValues ( )

protectedinherited

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

Definition at line 561 of file MooseVariableDataBase.C.

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

◆ fetchDofValues() [2/3]

void MooseVariableDataBase< RealEigenVector >::fetchDofValues ( )

protectedinherited

◆ fetchDofValues() [3/3]

void MooseVariableDataBase< RealEigenVector >::fetchDofValues ( )

protectedinherited

Definition at line 664 of file MooseVariableDataBase.C.

{
  bool is_transient = _subproblem.isTransient();
 
  auto n = _dof_indices.size() / _count;
  libmesh_assert(n);
 
  if (is_transient)
  {
    if (_need_u_dot || _need_grad_dot || _need_dof_values_dot)
    {
      libmesh_assert(_sys.solutionUDot());
      getArrayDofValues(*_sys.solutionUDot(), n, _dof_values_dot);
    }
    if (_need_u_dotdot || _need_grad_dotdot || _need_dof_values_dotdot)
    {
      libmesh_assert(_sys.solutionUDotDot());
      getArrayDofValues(*_sys.solutionUDot(), n, _dof_values_dotdot);
    }
    if (_need_u_dot_old || _need_dof_values_dot_old)
    {
      libmesh_assert(_sys.solutionUDotOld());
      getArrayDofValues(*_sys.solutionUDotOld(), n, _dof_values_dot_old);
    }
    if (_need_u_dotdot_old || _need_dof_values_dotdot_old)
    {
      libmesh_assert(_sys.solutionUDotDotOld());
      getArrayDofValues(*_sys.solutionUDotDotOld(), n, _dof_values_dotdot_old);
    }
  }
 
  for (auto tag : _required_vector_tags)
    if ((_subproblem.vectorTagType(tag) == Moose::VECTOR_TAG_RESIDUAL &&
         _subproblem.safeAccessTaggedVectors()) ||
        _subproblem.vectorTagType(tag) == Moose::VECTOR_TAG_SOLUTION)
      // tag is defined on problem but may not be used by a system
      if (_sys.hasVector(tag))
      {
        mooseAssert(_sys.getVector(tag).closed(),
                    "Vector with tag '" + std::to_string(tag) + "' should be closed");
        getArrayDofValues(_sys.getVector(tag), n, _vector_tags_dof_u[tag]);
      }
 
  if (_subproblem.safeAccessTaggedMatrices())
  {
    auto & active_coupleable_matrix_tags =
        _subproblem.getActiveFEVariableCoupleableMatrixTags(_tid);
    for (auto tag : active_coupleable_matrix_tags)
    {
      _matrix_tags_dof_u[tag].resize(n);
      if (_need_matrix_tag_dof_u[tag] || _need_matrix_tag_u[tag])
        if (_sys.hasMatrix(tag) && _sys.matrixTagActive(tag))
        {
          mooseAssert(_sys.getMatrix(tag).closed(),
                      "Matrix with tag '" + std::to_string(tag) + "' should be closed");
          auto & mat = _sys.getMatrix(tag);
          for (unsigned i = 0; i < n; i++)
            for (unsigned j = 0; j < _count; j++)
              _matrix_tags_dof_u[tag][i](j) = mat(_dof_indices[i] + j, _dof_indices[i] + j);
        }
    }
  }
 
  if (_need_du_dot_du || _need_dof_du_dot_du)
  {
    _dof_du_dot_du.resize(n);
    for (decltype(n) i = 0; i < n; ++i)
      _dof_du_dot_du[i] = _sys.duDotDu(_var.number());
  }
  if (_need_du_dotdot_du || _need_dof_du_dotdot_du)
  {
    _dof_du_dotdot_du.resize(n);
    for (decltype(n) i = 0; i < n; ++i)
      _dof_du_dotdot_du[i] = _sys.duDotDotDu();
  }
}

◆ getArrayDofValues()

template<typename OutputType >

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

protectedinherited

Definition at line 649 of file MooseVariableDataBase.C.

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

◆ getContinuity()

template<typename OutputType >

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

inlineoverridevirtual

Return the variable continuity.

Implements MooseVariableDataBase< OutputType >.

Definition at line 104 of file MooseVariableDataFV.h.

104{ return libMesh::DISCONTINUOUS; }

libMesh::DISCONTINUOUS

DISCONTINUOUS

◆ getDofIndices()

template<typename OutputType >

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

Definition at line 661 of file MooseVariableDataFV.C.

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

◆ getElementalValue()

template<typename OutputType >

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

Definition at line 636 of file MooseVariableDataFV.C.

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

◆ gradSln()

template<typename OutputType >

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

inherited

Local solution gradient getter.

Parameters

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

Definition at line 329 of file MooseVariableDataBase.C.

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

◆ gradSlnDot()

template<typename OutputType >

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

Local time derivative of solution gradient getter.

Definition at line 171 of file MooseVariableDataFV.C.

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

◆ gradSlnDotDot()

template<typename OutputType >

const MooseVariableDataFV< OutputType >::FieldVariableGradient & MooseVariableDataFV< OutputType >::gradSlnDotDot ( ) const

Local second time derivative of solution gradient getter.

Definition at line 186 of file MooseVariableDataFV.C.

{
  if (_sys.solutionUDotDot())
  {
    _var.requireQpComputations();
    _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`.");
}

◆ hasDirichletBC()

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::hasDirichletBC ( ) const

inline

checks if a Dirichlet BC exists on this face

Definition at line 279 of file MooseVariableDataFV.h.

279{ return _has_dirichlet_bc; }

◆ hasDoFsOnNodes()

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::hasDoFsOnNodes ( ) const

inlineoverridevirtual

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

Implements MooseVariableDataBase< OutputType >.

Definition at line 103 of file MooseVariableDataFV.h.

103{ return false; }

◆ increment()

template<typename OutputType >

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

inline

Increment getter.

Returns: The increment

Definition at line 271 of file MooseVariableDataFV.h.

271{ return _increment; }

MooseVariableDataFV::_increment

FieldVariableValue _increment

Increment in the variable used in dampers.

Definition MooseVariableDataFV.h:317

◆ initDofIndices()

template<typename OutputType >

const std::vector< dof_id_type > & MooseVariableDataFV< OutputType >::initDofIndices ( )

private

Definition at line 412 of file MooseVariableDataFV.C.

{
  Moose::initDofIndices(*this, *_elem);
  return _dof_indices;
}

◆ initializeSolnVars()

template<typename OutputType >

void MooseVariableDataFV< OutputType >::initializeSolnVars ( )

private

Definition at line 270 of file MooseVariableDataFV.C.

{
  auto && active_coupleable_matrix_tags =
      _sys.subproblem().getActiveFEVariableCoupleableMatrixTags(_tid);
  mooseAssert(_qrule, "We should have a non-null qrule");
  const auto nqp = _qrule->n_points();
 
  for (auto tag : _required_vector_tags)
    if (_need_vector_tag_u[tag])
    {
      _vector_tag_u[tag].resize(nqp);
      assignForAllQps(0, _vector_tag_u[tag], nqp);
    }
 
  for (auto tag : active_coupleable_matrix_tags)
    if (_need_matrix_tag_u[tag])
    {
      _matrix_tag_u[tag].resize(nqp);
      assignForAllQps(0, _matrix_tag_u[tag], nqp);
    }
 
  if (_need_second)
  {
    _second_u.resize(nqp);
    assignForAllQps(0, _second_u, nqp);
  }
 
  if (_need_curl)
  {
    _curl_u.resize(nqp);
    assignForAllQps(0, _curl_u, nqp);
  }
 
  if (_need_second_previous_nl)
  {
    _second_u_previous_nl.resize(nqp);
    assignForAllQps(0, _second_u_previous_nl, nqp);
  }
 
  if (_subproblem.isTransient())
  {
    if (_need_u_dot)
    {
      _u_dot.resize(nqp);
      assignForAllQps(0, _u_dot, nqp);
    }
 
    if (_need_u_dotdot)
    {
      _u_dotdot.resize(nqp);
      assignForAllQps(0, _u_dotdot, nqp);
    }
 
    if (_need_u_dot_old)
    {
      _u_dot_old.resize(nqp);
      assignForAllQps(0, _u_dot_old, nqp);
    }
 
    if (_need_u_dotdot_old)
    {
      _u_dotdot_old.resize(nqp);
      assignForAllQps(0, _u_dotdot_old, nqp);
    }
 
    if (_need_du_dot_du)
    {
      _du_dot_du.resize(nqp);
      assignForAllQps(0, _du_dot_du, nqp);
    }
 
    if (_need_du_dotdot_du)
    {
      _du_dotdot_du.resize(nqp);
      assignForAllQps(0, _du_dotdot_du, nqp);
    }
 
    if (_need_grad_dot)
    {
      _grad_u_dot.resize(nqp);
      assignForAllQps(0, _grad_u_dot, nqp);
    }
 
    if (_need_grad_dotdot)
    {
      _grad_u_dotdot.resize(nqp);
      assignForAllQps(0, _grad_u_dotdot, nqp);
    }
 
    if (_need_second_old)
    {
      _second_u_old.resize(nqp);
      assignForAllQps(0, _second_u_old, nqp);
    }
 
    if (_need_curl_old)
    {
      _curl_u_old.resize(nqp);
      assignForAllQps(0, _curl_u_old, nqp);
    }
 
    if (_need_second_older)
    {
      _second_u_older.resize(nqp);
      assignForAllQps(0, _second_u_older, nqp);
    }
  }
}

◆ insert() [1/2]

template<typename OutputType >

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

inherited

Set the current local DOF values to the input vector.

Definition at line 436 of file MooseVariableDataBase.C.

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

◆ insert() [2/2]

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

inherited

Definition at line 449 of file MooseVariableDataBase.C.

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

◆ insertSolutionTag()

template<typename OutputType >

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

protectedinherited

insert a solution tag into our tag containers

Definition at line 330 of file MooseVariableDataBase.h.

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

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

◆ isNodal()

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::isNodal ( ) const

inlineoverridevirtual

Returns: Whether this data is associated with a nodal variable

Implements MooseVariableDataBase< OutputType >.

Definition at line 102 of file MooseVariableDataFV.h.

102{ return false; }

◆ matrixTagValue()

template<typename OutputType >

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

inherited

Definition at line 232 of file MooseVariableDataBase.C.

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

◆ meshChanged()

template<typename OutputType >

void MooseVariableDataFV< OutputType >::meshChanged ( )

overridevirtual

Called on this object when the mesh changes.

Reimplemented from MeshChangedInterface.

Definition at line 779 of file MooseVariableDataFV.C.

{
  _prev_elem = nullptr;
}

◆ needsAD()

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::needsAD ( ) const

inline

Returns whether this data structure needs automatic differentiation calculations.

Definition at line 109 of file MooseVariableDataFV.h.

109{ return _need_ad; }

◆ needSolutionState()

template<typename OutputType >

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

protectedinherited

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

Definition at line 259 of file MooseVariableDataBase.C.

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

◆ nodalMatrixTagValue()

template<typename OutputType >

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

inherited

Definition at line 123 of file MooseVariableDataBase.C.

{
  if (isNodal())
  {
    if (tag >= _matrix_tags_dof_u.size())
    {
      _need_matrix_tag_dof_u.resize(tag + 1, false);
      const_cast<MooseVariableDataBase<OutputType> *>(this)->_matrix_tags_dof_u.resize(tag + 1);
    }
 
    _need_matrix_tag_dof_u[tag] = true;
 
    if (_sys.hasMatrix(tag))
      return _matrix_tags_dof_u[tag];
    else
      mooseError(
          "Tag ", tag, " is not associated with any matrix for nodal variable ", _var.name());
  }
  else
    mooseError("Nodal values can be requested only on nodal variables, variable '",
               _var.name(),
               "' is not nodal.");
}

◆ nodalValue()

template<typename OutputType >

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

inherited

Definition at line 498 of file MooseVariableDataBase.C.

{
  if (isNodal())
  {
    // Request the correct solution states and data members
    vectorTagDofValue(state);
    switch (state)
    {
      case Moose::Current:
        return _nodal_value;
 
      case Moose::Old:
        return _nodal_value_old;
 
      case Moose::Older:
        return _nodal_value_older;
 
      case Moose::PreviousNL:
        return _nodal_value_previous_nl;
 
      default:
        // We should never get here but gcc requires that we have a default. See
        // htpps://stackoverflow.com/questions/18680378/after-defining-case-for-all-enum-values-compiler-still-says-control-reaches-e
        mooseError("Unknown SolutionState!");
    }
  }
  else
    mooseError("Nodal values can be requested only on nodal variables, variable '",
               _var.name(),
               "' is not nodal.");
}

◆ nodalValueArray()

template<typename OutputType >

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

inherited

Definition at line 532 of file MooseVariableDataBase.C.

{
  if (isNodal())
  {
    // Request the correct solution states and data members
    vectorTagDofValue(state);
    switch (state)
    {
      case Moose::Current:
        return _nodal_value_array;
 
      case Moose::Old:
        return _nodal_value_old_array;
 
      case Moose::Older:
        return _nodal_value_older_array;
 
      default:
        mooseError("No current support for PreviousNL for nodal value array");
    }
  }
  else
    mooseError("Nodal values can be requested only on nodal variables, variable '",
               _var.name(),
               "' is not nodal.");
}

◆ nodalVectorTagValue()

template<typename OutputType >

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

inherited

Definition at line 100 of file MooseVariableDataBase.C.

{
  if (isNodal())
  {
    if (tag >= _need_vector_tag_dof_u.size())
      const_cast<MooseVariableDataBase<OutputType> *>(this)->resizeVectorTagData(tag);
 
    _need_vector_tag_dof_u[tag] = true;
 
    if (_sys.hasVector(tag))
      return _vector_tags_dof_u[tag];
    else
      mooseError(
          "Tag ", tag, " is not associated with any vector for nodal variable ", _var.name());
  }
  else
    mooseError("Nodal values can be requested only on nodal variables, variable '",
               _var.name(),
               "' is not nodal.");
}

◆ numberOfDofs()

template<typename OutputType >

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

Definition at line 509 of file MooseVariableDataFV.h.

{
  return dofIndices().size();
}

◆ oldestSolutionStateRequested()

template<typename OutputType >

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

inherited

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

Definition at line 252 of file MooseVariableDataBase.C.

{
  return _max_state;
}

◆ prepareAux()

template<typename OutputType >

void MooseVariableDataBase< OutputType >::prepareAux ( )

inlineinherited

Clear aux state.

Definition at line 142 of file MooseVariableDataBase.h.

142{ _has_dof_values = false; }

◆ prepareIC()

template<typename OutputType >

void MooseVariableDataFV< OutputType >::prepareIC ( )

prepare the initial condition

Definition at line 766 of file MooseVariableDataFV.C.

{
  // TODO: implement this function
  initDofIndices();
  _vector_tags_dof_u[_solution_tag].resize(_dof_indices.size());
 
  mooseAssert(_qrule, "We should have a non-null qrule");
  const auto nqp = _qrule->n_points();
  _vector_tag_u[_solution_tag].resize(nqp);
}

◆ resizeVectorTagData()

template<typename OutputType >

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

protectedinherited

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

Definition at line 149 of file MooseVariableDataBase.C.

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

◆ safeToComputeADUDot()

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::safeToComputeADUDot ( ) const

inlineprivate

Helper method that tells us whether it's safe to compute _ad_u_dot.

Definition at line 473 of file MooseVariableDataFV.h.

{
  // If we don't have a time integrator then we have no way to calculate _ad_u_dot because we rely
  // on calls to TimeIntegrator::computeADTimeDerivatives. Another potential situation where
  // _ad_u_dot computation is potentially troublesome is if we are an auxiliary variable which uses
  // the auxiliary system copy of the time integrator. Some derived time integrator classes do setup
  // in their solve() method, and that solve() method only happens for the nonlinear system copy of
  // the time integrator.
  return _time_integrator && (_var.kind() == Moose::VAR_SOLVER);
}

◆ secondSln()

template<typename OutputType >

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

Local solution second spatial derivative getter.

Parameters

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

Definition at line 202 of file MooseVariableDataFV.C.

{
  _var.requireQpComputations();
  switch (state)
  {
    case Moose::Current:
    {
      _need_second = true;
      return _second_u;
    }
 
    case Moose::Old:
    {
      _need_second_old = true;
      return _second_u_old;
    }
 
    case Moose::Older:
    {
      _need_second_older = true;
      return _second_u_older;
    }
 
    case Moose::PreviousNL:
    {
      _need_second_previous_nl = true;
      return _second_u_previous_nl;
    }
 
    default:
      // We should never get here but gcc requires that we have a default. See
      // htpps://stackoverflow.com/questions/18680378/after-defining-case-for-all-enum-values-compiler-still-says-control-reaches-e
      mooseError("Unknown SolutionState!");
  }
}

◆ setActiveTags()

template<typename OutputType >

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

inherited

Set the active vector tags.

Parameters

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

Definition at line 314 of file MooseVariableDataBase.h.

{
  _required_vector_tags = _solution_tags;
  for (const auto tag : vtags)
    _required_vector_tags.insert(tag);
 
  if (!_required_vector_tags.empty())
  {
    const auto largest_tag_id = *_required_vector_tags.rbegin();
    if (largest_tag_id >= _need_vector_tag_dof_u.size())
      resizeVectorTagData(largest_tag_id);
  }
}

◆ setDofValue()

template<typename OutputType >

void MooseVariableDataFV< OutputType >::setDofValue	(	const OutputData &	value,
		unsigned int	index
	)

dof value setters

Definition at line 608 of file MooseVariableDataFV.C.

{
  mooseAssert(index == 0, "We only ever have one dof value locally");
  _vector_tags_dof_u[_solution_tag][index] = value;
  _has_dof_values = true;
 
  auto & u = _vector_tag_u[_solution_tag];
  // Update the qp values as well
  for (const auto qp : index_range(u))
    u[qp] = value;
 
  if (_need_ad_u)
    for (const auto qp : index_range(_ad_u))
      _ad_u[qp] = value;
}

◆ setDofValues()

template<typename OutputType >

void MooseVariableDataFV< OutputType >::setDofValues ( const DenseVector< OutputData > & values )

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

Definition at line 626 of file MooseVariableDataFV.C.

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

◆ setGeometry()

template<typename OutputType >

void MooseVariableDataFV< OutputType >::setGeometry ( Moose::GeometryType gm_type )

Set the geometry type before calculating variables values.

Parameters

gm_type The type type of geometry; either Volume or Face

Definition at line 79 of file MooseVariableDataFV.C.

{
  switch (gm_type)
  {
    case Moose::Volume:
    {
      _qrule = _assembly.qRule();
      // TODO: set integration multiplier to cell volume
      break;
    }
    case Moose::Face:
    {
      _qrule = _assembly.qRuleFace();
      // TODO: set integration multiplier to face area
      break;
    }
  }
}

◆ setNodalValue() [1/2]

template<typename OutputType >

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

inherited

Set nodal value.

Definition at line 382 of file MooseVariableDataBase.C.

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

◆ setNodalValue() [2/2]

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

inherited

Definition at line 407 of file MooseVariableDataBase.C.

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

◆ sizeMatrixTagData()

template<typename OutputType >

void MooseVariableDataBase< OutputType >::sizeMatrixTagData ( )

inherited

size matrix tag data

Definition at line 87 of file MooseVariableDataBase.C.

{
  auto num_matrix_tags = _subproblem.numMatrixTags();
 
  _matrix_tags_dof_u.resize(num_matrix_tags);
  _need_matrix_tag_dof_u.resize(num_matrix_tags, false);
 
  _need_matrix_tag_u.resize(num_matrix_tags, false);
  _matrix_tag_u.resize(num_matrix_tags);
}

◆ sln()

template<typename OutputType >

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

Local solution value.

Definition at line 163 of file MooseVariableDataFV.C.

{
  _var.requireQpComputations();
  return MooseVariableDataBase<OutputType>::sln(state);
}

◆ stateToTagHelper()

template<typename OutputType >

template<typename ReturnType , typename Functor >

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

protectedinherited

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

Definition at line 271 of file MooseVariableDataBase.C.

{
  if (state > 0)
  {
    // We need to request all states that are between current and the requested state
    stateToTagHelper<ReturnType>(Moose::SolutionState(static_cast<int>(state) - 1), functor);
    needSolutionState(cast_int<unsigned int>(state));
  }
 
  switch (state)
  {
    case Moose::Current:
      return functor(_subproblem.getVectorTagID(Moose::SOLUTION_TAG));
 
    case Moose::Old:
    {
      _old_solution_tag = _subproblem.getVectorTagID(Moose::OLD_SOLUTION_TAG);
      insertSolutionTag(_old_solution_tag);
      return functor(_old_solution_tag);
    }
 
    case Moose::Older:
    {
      _older_solution_tag = _subproblem.getVectorTagID(Moose::OLDER_SOLUTION_TAG);
      insertSolutionTag(_older_solution_tag);
      return functor(_older_solution_tag);
    }
 
    case Moose::PreviousNL:
    {
      _previous_nl_solution_tag = _subproblem.getVectorTagID(Moose::PREVIOUS_NL_SOLUTION_TAG);
      insertSolutionTag(_previous_nl_solution_tag);
      return functor(_previous_nl_solution_tag);
    }
 
    default:
      // We should never get here but gcc requires that we have a default. See
      // htpps://stackoverflow.com/questions/18680378/after-defining-case-for-all-enum-values-compiler-still-says-control-reaches-e
      mooseError("Unknown SolutionState!");
  }
}

◆ uDot()

template<typename OutputType >

const MooseVariableDataFV< OutputType >::FieldVariableValue & MooseVariableDataFV< OutputType >::uDot ( ) const

Definition at line 100 of file MooseVariableDataFV.C.

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

◆ uDotDot()

template<typename OutputType >

const MooseVariableDataFV< OutputType >::FieldVariableValue & MooseVariableDataFV< OutputType >::uDotDot ( ) const

Definition at line 115 of file MooseVariableDataFV.C.

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

◆ uDotDotOld()

template<typename OutputType >

const MooseVariableDataFV< OutputType >::FieldVariableValue & MooseVariableDataFV< OutputType >::uDotDotOld ( ) const

Definition at line 147 of file MooseVariableDataFV.C.

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

◆ uDotOld()

template<typename OutputType >

const MooseVariableDataFV< OutputType >::FieldVariableValue & MooseVariableDataFV< OutputType >::uDotOld ( ) const

Definition at line 131 of file MooseVariableDataFV.C.

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

◆ validParams()

InputParameters MeshChangedInterface::validParams ( )

staticinherited

Definition at line 15 of file MeshChangedInterface.C.

{
  InputParameters params = emptyInputParameters();
  return params;
}

Referenced by AuxKernelBase::validParams(), AuxScalarKernel::validParams(), LinearSystemContributionObject::validParams(), ResidualObject::validParams(), and FVInterfaceKernel::validParams().

◆ var()

template<typename OutputType >

virtual const MooseVariableFV< OutputType > & MooseVariableDataFV< OutputType >::var ( ) const

inlineoverrideprotectedvirtual

Returns: The variable to which the data in this class belongs to

Reimplemented from MooseVariableDataBase< OutputType >.

Definition at line 284 of file MooseVariableDataFV.h.

284{ return _var; }

◆ vectorTagDofValue() [1/2]

template<typename OutputType >

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

inherited

Definition at line 342 of file MooseVariableDataBase.C.

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

◆ vectorTagDofValue() [2/2]

template<typename OutputType >

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

inherited

Definition at line 198 of file MooseVariableDataBase.C.

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

◆ vectorTagGradient()

template<typename OutputType >

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

inherited

Definition at line 215 of file MooseVariableDataBase.C.

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

◆ vectorTagValue()

template<typename OutputType >

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

inherited

Definition at line 181 of file MooseVariableDataBase.C.

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

◆ zeroSizeDofValues()

template<typename OutputType >

void MooseVariableDataBase< OutputType >::zeroSizeDofValues ( )

protectedinherited

Definition at line 743 of file MooseVariableDataBase.C.

{
  if (_subproblem.isTransient())
  {
    _dof_values_dot.resize(0);
    _dof_values_dotdot.resize(0);
    _dof_values_dot_old.resize(0);
    _dof_values_dotdot_old.resize(0);
    _dof_du_dot_du.resize(0);
    _dof_du_dotdot_du.resize(0);
  }
 
  for (auto & dof_values : _vector_tags_dof_u)
    dof_values.resize(0);
 
  _has_dof_values = false;
}

Friends And Related Symbol Documentation

◆ Moose::initDofIndices

template<typename OutputType >

void Moose::initDofIndices	(	MooseVariableDataFV< OutputType > &	,
		const Elem &
	)

friend

Member Data Documentation

◆ _ad_dof_values

template<typename OutputType >

MooseArray<ADReal> MooseVariableDataFV< OutputType >::_ad_dof_values

private

Definition at line 361 of file MooseVariableDataFV.h.

◆ _ad_dofs_dot

template<typename OutputType >

MooseArray<ADReal> MooseVariableDataFV< OutputType >::_ad_dofs_dot

private

Definition at line 362 of file MooseVariableDataFV.h.

◆ _ad_dofs_dotdot

template<typename OutputType >

MooseArray<ADReal> MooseVariableDataFV< OutputType >::_ad_dofs_dotdot

private

Definition at line 363 of file MooseVariableDataFV.h.

◆ _ad_grad_u

template<typename OutputType >

ADTemplateVariableGradient<OutputShape> MooseVariableDataFV< OutputType >::_ad_grad_u

private

Definition at line 359 of file MooseVariableDataFV.h.

◆ _ad_grad_u_dot

template<typename OutputType >

ADTemplateVariableGradient<OutputShape> MooseVariableDataFV< OutputType >::_ad_grad_u_dot

private

Definition at line 366 of file MooseVariableDataFV.h.

◆ _ad_real_dummy

template<typename OutputType >

ADReal MooseVariableDataFV< OutputType >::_ad_real_dummy = 0

private

A dummy ADReal variable.

Definition at line 410 of file MooseVariableDataFV.h.

◆ _ad_second_u

template<typename OutputType >

ADTemplateVariableSecond<OutputShape> MooseVariableDataFV< OutputType >::_ad_second_u

private

Definition at line 360 of file MooseVariableDataFV.h.

◆ _ad_u

template<typename OutputType >

ADTemplateVariableValue<OutputShape> MooseVariableDataFV< OutputType >::_ad_u

private

AD u.

Definition at line 358 of file MooseVariableDataFV.h.

◆ _ad_u_dot

template<typename OutputType >

ADTemplateVariableValue<OutputShape> MooseVariableDataFV< OutputType >::_ad_u_dot

private

Definition at line 364 of file MooseVariableDataFV.h.

◆ _ad_u_dotdot

template<typename OutputType >

ADTemplateVariableValue<OutputShape> MooseVariableDataFV< OutputType >::_ad_u_dotdot

private

Definition at line 365 of file MooseVariableDataFV.h.

◆ _ad_zero

template<typename OutputType >

const ADReal MooseVariableDataFV< OutputType >::_ad_zero

private

A zero AD variable.

Definition at line 320 of file MooseVariableDataFV.h.

◆ _assembly

template<typename OutputType >

const Assembly& MooseVariableDataFV< OutputType >::_assembly

private

Definition at line 308 of file MooseVariableDataFV.h.

◆ _continuity

template<typename OutputType >

libMesh::FEContinuity MooseVariableDataFV< OutputType >::_continuity

private

Continuity type of the variable.

Definition at line 314 of file MooseVariableDataFV.h.

◆ _count

template<typename OutputType >

unsigned int MooseVariableDataBase< OutputType >::_count

protectedinherited

Number of components of the associated variable.

Definition at line 202 of file MooseVariableDataBase.h.

◆ _curl_u

template<typename OutputType >

FieldVariableCurl MooseVariableDataFV< OutputType >::_curl_u

private

curl_u

Definition at line 353 of file MooseVariableDataFV.h.

◆ _curl_u_old

template<typename OutputType >

FieldVariableCurl MooseVariableDataFV< OutputType >::_curl_u_old

private

Definition at line 354 of file MooseVariableDataFV.h.

◆ _curl_u_older

template<typename OutputType >

FieldVariableCurl MooseVariableDataFV< OutputType >::_curl_u_older

private

Definition at line 355 of file MooseVariableDataFV.h.

◆ _displaced

template<typename OutputType >

const bool MooseVariableDataFV< OutputType >::_displaced

private

Whether this variable is being calculated on a displaced system.

Definition at line 404 of file MooseVariableDataFV.h.

◆ _dof_du_dot_du

template<typename OutputType >

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

protectedinherited

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

Definition at line 281 of file MooseVariableDataBase.h.

◆ _dof_du_dotdot_du

template<typename OutputType >

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

protectedinherited

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

Definition at line 284 of file MooseVariableDataBase.h.

◆ _dof_indices

template<typename OutputType >

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

protectedinherited

The dof indices for the current element.

Definition at line 224 of file MooseVariableDataBase.h.

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

◆ _dof_map

template<typename OutputType >

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

protectedinherited

The degree of freedom map from libMesh.

Definition at line 199 of file MooseVariableDataBase.h.

◆ _dof_values_dot

template<typename OutputType >

DofValues MooseVariableDataBase< OutputType >::_dof_values_dot

protectedinherited

time derivative of the solution values

Definition at line 273 of file MooseVariableDataBase.h.

◆ _dof_values_dot_old

template<typename OutputType >

DofValues MooseVariableDataBase< OutputType >::_dof_values_dot_old

protectedinherited

the previous time step's solution value time derivative

Definition at line 277 of file MooseVariableDataBase.h.

◆ _dof_values_dotdot

template<typename OutputType >

DofValues MooseVariableDataBase< OutputType >::_dof_values_dotdot

protectedinherited

second time derivative of the solution values

Definition at line 275 of file MooseVariableDataBase.h.

◆ _dof_values_dotdot_old

template<typename OutputType >

DofValues MooseVariableDataBase< OutputType >::_dof_values_dotdot_old

protectedinherited

the previous time step's solution value second time derivative

Definition at line 279 of file MooseVariableDataBase.h.

◆ _du_dot_du

template<typename OutputType >

VariableValue MooseVariableDataFV< OutputType >::_du_dot_du

private

derivative of u_dot wrt u

Definition at line 383 of file MooseVariableDataFV.h.

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

◆ _du_dotdot_du

template<typename OutputType >

VariableValue MooseVariableDataFV< OutputType >::_du_dotdot_du

private

derivative of u_dotdot wrt u

Definition at line 386 of file MooseVariableDataFV.h.

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

◆ _elem

template<typename OutputType >

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

private

The current elem.

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

Definition at line 394 of file MooseVariableDataFV.h.

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

◆ _element_type

template<typename OutputType >

Moose::ElementType MooseVariableDataFV< OutputType >::_element_type

private

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

Definition at line 311 of file MooseVariableDataFV.h.

◆ _fe_type

template<typename OutputType >

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

private

Definition at line 304 of file MooseVariableDataFV.h.

◆ _fv_elemental_kernel_query_cache

template<typename OutputType >

TheWarehouse::QueryCache MooseVariableDataFV< OutputType >::_fv_elemental_kernel_query_cache

private

Cached warehouse query for FVElementalKernels.

Definition at line 413 of file MooseVariableDataFV.h.

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

◆ _fv_flux_kernel_query_cache

template<typename OutputType >

TheWarehouse::QueryCache MooseVariableDataFV< OutputType >::_fv_flux_kernel_query_cache

private

Cached warehouse query for FVFluxKernels.

Definition at line 415 of file MooseVariableDataFV.h.

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

◆ _grad_u_dot

template<typename OutputType >

FieldVariableGradient MooseVariableDataFV< OutputType >::_grad_u_dot

private

grad_u dots

Definition at line 343 of file MooseVariableDataFV.h.

◆ _grad_u_dotdot

template<typename OutputType >

FieldVariableGradient MooseVariableDataFV< OutputType >::_grad_u_dotdot

private

Definition at line 344 of file MooseVariableDataFV.h.

◆ _has_dirichlet_bc

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_has_dirichlet_bc

private

if this variable has a dirichlet bc defined on a particular face

Definition at line 401 of file MooseVariableDataFV.h.

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

◆ _has_dof_values

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_has_dof_values

protectedinherited

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

Definition at line 206 of file MooseVariableDataBase.h.

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

◆ _increment

template<typename OutputType >

FieldVariableValue MooseVariableDataFV< OutputType >::_increment

private

Increment in the variable used in dampers.

Definition at line 317 of file MooseVariableDataFV.h.

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

◆ _matrix_tag_u

template<typename OutputType >

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

protectedinherited

Definition at line 238 of file MooseVariableDataBase.h.

◆ _matrix_tags_dof_u

template<typename OutputType >

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

protectedinherited

Definition at line 232 of file MooseVariableDataBase.h.

◆ _max_state

template<typename OutputType >

unsigned int MooseVariableDataBase< OutputType >::_max_state

protectedinherited

The maximum number of older solution states our variable needs.

Definition at line 209 of file MooseVariableDataBase.h.

◆ _mci_feproblem

FEProblemBase& MeshChangedInterface::_mci_feproblem

protectedinherited

Reference to FEProblemBase instance.

Definition at line 44 of file MeshChangedInterface.h.

Referenced by MeshChangedInterface::MeshChangedInterface().

◆ _need_ad

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_ad

mutableprivate

AD flags.

Definition at line 334 of file MooseVariableDataFV.h.

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

◆ _need_ad_grad_u

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_ad_grad_u

mutableprivate

Definition at line 338 of file MooseVariableDataFV.h.

◆ _need_ad_grad_u_dot

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_ad_grad_u_dot

mutableprivate

Definition at line 339 of file MooseVariableDataFV.h.

◆ _need_ad_second_u

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_ad_second_u

mutableprivate

Definition at line 340 of file MooseVariableDataFV.h.

◆ _need_ad_u

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_ad_u

mutableprivate

Definition at line 335 of file MooseVariableDataFV.h.

◆ _need_ad_u_dot

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_ad_u_dot

mutableprivate

Definition at line 336 of file MooseVariableDataFV.h.

◆ _need_ad_u_dotdot

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_ad_u_dotdot

mutableprivate

Definition at line 337 of file MooseVariableDataFV.h.

◆ _need_curl

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_curl

mutableprivate

curl flags

Definition at line 329 of file MooseVariableDataFV.h.

◆ _need_curl_old

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_curl_old

mutableprivate

Definition at line 330 of file MooseVariableDataFV.h.

◆ _need_curl_older

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_curl_older

mutableprivate

Definition at line 331 of file MooseVariableDataFV.h.

◆ _need_dof_du_dot_du

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_dof_du_dot_du

mutableprotectedinherited

Definition at line 269 of file MooseVariableDataBase.h.

◆ _need_dof_du_dotdot_du

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_dof_du_dotdot_du

mutableprotectedinherited

Definition at line 270 of file MooseVariableDataBase.h.

◆ _need_dof_values_dot

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_dof_values_dot

mutableprotectedinherited

local solution flags

Definition at line 265 of file MooseVariableDataBase.h.

◆ _need_dof_values_dot_old

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_dof_values_dot_old

mutableprotectedinherited

Definition at line 267 of file MooseVariableDataBase.h.

◆ _need_dof_values_dotdot

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_dof_values_dotdot

mutableprotectedinherited

Definition at line 266 of file MooseVariableDataBase.h.

◆ _need_dof_values_dotdot_old

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_dof_values_dotdot_old

mutableprotectedinherited

Definition at line 268 of file MooseVariableDataBase.h.

◆ _need_du_dot_du

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_du_dot_du

mutableprotectedinherited

Definition at line 257 of file MooseVariableDataBase.h.

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

◆ _need_du_dotdot_du

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_du_dotdot_du

mutableprotectedinherited

Definition at line 258 of file MooseVariableDataBase.h.

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

◆ _need_grad_dot

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_grad_dot

mutableprotectedinherited

gradient dot flags

Definition at line 261 of file MooseVariableDataBase.h.

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

◆ _need_grad_dotdot

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_grad_dotdot

mutableprotectedinherited

Definition at line 262 of file MooseVariableDataBase.h.

◆ _need_matrix_tag_dof_u

template<typename OutputType >

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

mutableprotectedinherited

Definition at line 227 of file MooseVariableDataBase.h.

◆ _need_matrix_tag_u

template<typename OutputType >

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

mutableprotectedinherited

Definition at line 239 of file MooseVariableDataBase.h.

◆ _need_second

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_second

mutableprivate

SolutionState second_u flags.

Definition at line 323 of file MooseVariableDataFV.h.

◆ _need_second_old

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_second_old

mutableprivate

Definition at line 324 of file MooseVariableDataFV.h.

◆ _need_second_older

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_second_older

mutableprivate

Definition at line 325 of file MooseVariableDataFV.h.

◆ _need_second_previous_nl

template<typename OutputType >

bool MooseVariableDataFV< OutputType >::_need_second_previous_nl

mutableprivate

Definition at line 326 of file MooseVariableDataFV.h.

◆ _need_u_dot

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_u_dot

mutableprotectedinherited

u dot flags

Definition at line 253 of file MooseVariableDataBase.h.

◆ _need_u_dot_old

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_u_dot_old

mutableprotectedinherited

Definition at line 255 of file MooseVariableDataBase.h.

◆ _need_u_dotdot

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_u_dotdot

mutableprotectedinherited

Definition at line 254 of file MooseVariableDataBase.h.

◆ _need_u_dotdot_old

template<typename OutputType >

bool MooseVariableDataBase< OutputType >::_need_u_dotdot_old

mutableprotectedinherited

Definition at line 256 of file MooseVariableDataBase.h.

◆ _need_vector_tag_dof_u

template<typename OutputType >

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

mutableprotectedinherited

Definition at line 226 of file MooseVariableDataBase.h.

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

◆ _need_vector_tag_grad

template<typename OutputType >

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

mutableprotectedinherited

Definition at line 237 of file MooseVariableDataBase.h.

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

◆ _need_vector_tag_u

template<typename OutputType >

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

mutableprotectedinherited

Definition at line 235 of file MooseVariableDataBase.h.

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

◆ _nodal_value

template<typename OutputType >

OutputType MooseVariableDataBase< OutputType >::_nodal_value

protectedinherited

Nodal values.

Definition at line 242 of file MooseVariableDataBase.h.

◆ _nodal_value_array

template<typename OutputType >

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_array

protectedinherited

Nodal values as MooseArrays for use with AuxKernels.

Definition at line 248 of file MooseVariableDataBase.h.

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

◆ _nodal_value_dot

template<typename OutputType >

OutputType MooseVariableDataBase< OutputType >::_nodal_value_dot

protectedinherited

nodal values of u_dot

Definition at line 287 of file MooseVariableDataBase.h.

◆ _nodal_value_dot_old

template<typename OutputType >

OutputType MooseVariableDataBase< OutputType >::_nodal_value_dot_old

protectedinherited

nodal values of u_dot_old

Definition at line 291 of file MooseVariableDataBase.h.

◆ _nodal_value_dotdot

template<typename OutputType >

OutputType MooseVariableDataBase< OutputType >::_nodal_value_dotdot

protectedinherited

nodal values of u_dotdot

Definition at line 289 of file MooseVariableDataBase.h.

◆ _nodal_value_dotdot_old

template<typename OutputType >

OutputType MooseVariableDataBase< OutputType >::_nodal_value_dotdot_old

protectedinherited

nodal values of u_dotdot_old

Definition at line 293 of file MooseVariableDataBase.h.

◆ _nodal_value_old

template<typename OutputType >

OutputType MooseVariableDataBase< OutputType >::_nodal_value_old

protectedinherited

Definition at line 243 of file MooseVariableDataBase.h.

◆ _nodal_value_old_array

template<typename OutputType >

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_old_array

protectedinherited

Definition at line 249 of file MooseVariableDataBase.h.

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

◆ _nodal_value_older

template<typename OutputType >

OutputType MooseVariableDataBase< OutputType >::_nodal_value_older

protectedinherited

Definition at line 244 of file MooseVariableDataBase.h.

◆ _nodal_value_older_array

template<typename OutputType >

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_older_array

protectedinherited

Definition at line 250 of file MooseVariableDataBase.h.

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

◆ _nodal_value_previous_nl

template<typename OutputType >

OutputType MooseVariableDataBase< OutputType >::_nodal_value_previous_nl

protectedinherited

Definition at line 245 of file MooseVariableDataBase.h.

◆ _old_solution_tag

template<typename OutputType >

TagID MooseVariableDataBase< OutputType >::_old_solution_tag

protectedinherited

The vector tag ID corresponding to the old solution vector.

Definition at line 215 of file MooseVariableDataBase.h.

◆ _older_solution_tag

template<typename OutputType >

TagID MooseVariableDataBase< OutputType >::_older_solution_tag

protectedinherited

The vector tag ID corresponding to the older solution vector.

Definition at line 218 of file MooseVariableDataBase.h.

◆ _prev_elem

template<typename OutputType >

const Elem* MooseVariableDataFV< OutputType >::_prev_elem = nullptr

mutableprivate

used to keep track of when dof indices are out of date

Definition at line 396 of file MooseVariableDataFV.h.

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

◆ _previous_nl_solution_tag

template<typename OutputType >

TagID MooseVariableDataBase< OutputType >::_previous_nl_solution_tag

protectedinherited

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

Definition at line 221 of file MooseVariableDataBase.h.

◆ _qrule

template<typename OutputType >

const libMesh::QBase* MooseVariableDataFV< OutputType >::_qrule

private

The quadrature rule.

Definition at line 407 of file MooseVariableDataFV.h.

◆ _required_vector_tags

template<typename OutputType >

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

protectedinherited

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

Definition at line 296 of file MooseVariableDataBase.h.

◆ _second_u

template<typename OutputType >

FieldVariableSecond MooseVariableDataFV< OutputType >::_second_u

private

second_u

Definition at line 347 of file MooseVariableDataFV.h.

◆ _second_u_old

template<typename OutputType >

FieldVariableSecond MooseVariableDataFV< OutputType >::_second_u_old

private

Definition at line 348 of file MooseVariableDataFV.h.

◆ _second_u_older

template<typename OutputType >

FieldVariableSecond MooseVariableDataFV< OutputType >::_second_u_older

private

Definition at line 349 of file MooseVariableDataFV.h.

◆ _second_u_previous_nl

template<typename OutputType >

FieldVariableSecond MooseVariableDataFV< OutputType >::_second_u_previous_nl

private

Definition at line 350 of file MooseVariableDataFV.h.

◆ _solution_tag

template<typename OutputType >

TagID MooseVariableDataBase< OutputType >::_solution_tag

protectedinherited

The vector tag ID corresponding to the solution vector.

Definition at line 212 of file MooseVariableDataBase.h.

◆ _solution_tags

template<typename OutputType >

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

protectedinherited

The set of solution tags we need to evaluate.

Definition at line 299 of file MooseVariableDataBase.h.

◆ _subproblem

template<typename OutputType >

const SubProblem& MooseVariableDataBase< OutputType >::_subproblem

protectedinherited

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

Definition at line 193 of file MooseVariableDataBase.h.

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

◆ _sys

template<typename OutputType >

SystemBase& MooseVariableDataBase< OutputType >::_sys

protectedinherited

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

Definition at line 190 of file MooseVariableDataBase.h.

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

◆ _tid

template<typename OutputType >

const THREAD_ID MooseVariableDataBase< OutputType >::_tid

protectedinherited

The thread ID that this object is on.

Definition at line 196 of file MooseVariableDataBase.h.

◆ _time_integrator

template<typename OutputType >

const TimeIntegrator* const MooseVariableDataFV< OutputType >::_time_integrator

private

Pointer to time integrator.

Definition at line 389 of file MooseVariableDataFV.h.

◆ _u_dot

template<typename OutputType >

FieldVariableValue MooseVariableDataFV< OutputType >::_u_dot

private

u_dot (time derivative)

Definition at line 371 of file MooseVariableDataFV.h.

◆ _u_dot_old

template<typename OutputType >

FieldVariableValue MooseVariableDataFV< OutputType >::_u_dot_old

private

u_dot_old (time derivative)

Definition at line 377 of file MooseVariableDataFV.h.

◆ _u_dotdot

template<typename OutputType >

FieldVariableValue MooseVariableDataFV< OutputType >::_u_dotdot

private

u_dotdot (second time derivative)

Definition at line 374 of file MooseVariableDataFV.h.

◆ _u_dotdot_old

template<typename OutputType >

FieldVariableValue MooseVariableDataFV< OutputType >::_u_dotdot_old

private

u_dotdot_old (second time derivative)

Definition at line 380 of file MooseVariableDataFV.h.

◆ _var

template<typename OutputType >

const MooseVariableFV<OutputType>& MooseVariableDataFV< OutputType >::_var

private

A const reference to the owning MooseVariableFV object.

Definition at line 302 of file MooseVariableDataFV.h.

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

◆ _var_num

template<typename OutputType >

const unsigned int MooseVariableDataFV< OutputType >::_var_num

private

Definition at line 306 of file MooseVariableDataFV.h.

◆ _vector_tag_grad

template<typename OutputType >

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

protectedinherited

Definition at line 236 of file MooseVariableDataBase.h.

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

◆ _vector_tag_u

template<typename OutputType >

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

protectedinherited

Definition at line 234 of file MooseVariableDataBase.h.

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

◆ _vector_tags_dof_u

template<typename OutputType >

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

protectedinherited

Definition at line 230 of file MooseVariableDataBase.h.

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

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

include/variables/MooseVariableDataFV.h
src/variables/MooseVariableDataFV.C

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ ADDofValue

◆ ADDofValues

◆ DofValue

◆ DofValues

◆ FieldVariableCurl

◆ FieldVariableDivergence

◆ FieldVariableGradient

◆ FieldVariableSecond

◆ FieldVariableValue

◆ OutputData

◆ OutputDivergence

◆ OutputGradient

◆ OutputSecond

◆ OutputShape

◆ OutputShapeDivergence

◆ OutputShapeGradient

◆ OutputShapeSecond

Constructor & Destructor Documentation

◆ MooseVariableDataFV()

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ adDofValues()

◆ adDofValuesDot()

◆ adGradSln()

◆ adGradSlnDot()

◆ adSecondSln()

◆ adSln()

◆ adUDot()

◆ adUDotDot()

◆ assignNodalValue() [1/3]

◆ assignNodalValue() [2/3]

◆ assignNodalValue() [3/3]

◆ clearDofIndices()

◆ computeAD()

◆ computeIncrementAtQps()

◆ computeValues()

◆ computeValuesFace()

◆ curlSln()

◆ currentElem()

◆ dofIndices()

◆ dofValues()

◆ dofValuesDot()

◆ dofValuesDotDot()

◆ dofValuesDotDotOld()

◆ dofValuesDotOld()

◆ dofValuesDuDotDotDu()

◆ dofValuesDuDotDu()

◆ dofValuesOld()

◆ dofValuesOlder()

◆ dofValuesPreviousNL()

◆ duDotDotDu()

◆ duDotDu()

◆ fetchADDofValues()

◆ fetchDofValues() [1/3]

◆ fetchDofValues() [2/3]

◆ fetchDofValues() [3/3]

◆ getArrayDofValues()

◆ getContinuity()

◆ getDofIndices()

◆ getElementalValue()

◆ gradSln()

◆ gradSlnDot()

◆ gradSlnDotDot()

◆ hasDirichletBC()

◆ hasDoFsOnNodes()

◆ increment()

◆ initDofIndices()

◆ initializeSolnVars()

◆ insert() [1/2]