Class holding the data members for linear finite volume variables. More...

#include <MooseVariableDataLinearFV.h>

Inheritance diagram for MooseVariableDataLinearFV< 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

Public Member Functions
	MooseVariableDataLinearFV (const MooseLinearVariableFV< 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. More...

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

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

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

void	setDofValues (const DenseVector< OutputData > &values)
	Set local DOF values to the entries of `values` . More...

void	setDofValue (const OutputData &value, unsigned int index)
	Set local DOF value at `index` to `value` . More...

void	getDofIndices (const Elem *elem, std::vector< dof_id_type > &dof_indices) const
	Get the dof indices for an element. More...

const std::vector< dof_id_type > &	dofIndices () const
	Get the dof indices of the current element. More...

unsigned int	numberOfDofs () const
	Get the number of dofs on the current element. More...

void	clearDofIndices ()
	Clear the dof indices in the cache. More...

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

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

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

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

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

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

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

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

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

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

const DoFValue &	dofValues () const

const DoFValue &	dofValuesOld () const

const DoFValue &	dofValuesOlder () const

const DoFValue &	dofValuesPreviousNL () const

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

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

const FieldVariableValue &	vectorTagValue (TagID tag) const

const FieldVariableGradient &	vectorTagGradient (TagID tag) const

const FieldVariableValue &	matrixTagValue (TagID tag) const

const DoFValue &	nodalVectorTagValue (TagID tag) const

const DoFValue &	nodalMatrixTagValue (TagID tag) const

const DoFValue &	vectorTagDofValue (TagID tag) const

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

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

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

Protected Member Functions
virtual const MooseLinearVariableFV< OutputType > &	var () const override
	Get the corresponding variable. More...

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

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

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

template<>
void	fetchDoFValues ()

template<>
void	fetchDoFValues ()

void	zeroSizeDofValues ()

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

void	assignNodalValue ()

template<>
void	assignNodalValue ()

template<>
void	assignNodalValue ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

std::vector< bool >	_need_vector_tag_dof_u

std::vector< bool >	_need_matrix_tag_dof_u

std::vector< DoFValue >	_vector_tags_dof_u

std::vector< DoFValue >	_matrix_tags_dof_u

std::vector< FieldVariableValue >	_vector_tag_u

std::vector< bool >	_need_vector_tag_u

std::vector< FieldVariableGradient >	_vector_tag_grad

std::vector< bool >	_need_vector_tag_grad

std::vector< FieldVariableValue >	_matrix_tag_u

std::vector< bool >	_need_matrix_tag_u

OutputType	_nodal_value
	Nodal values. More...

OutputType	_nodal_value_old

OutputType	_nodal_value_older

OutputType	_nodal_value_previous_nl

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

MooseArray< OutputType >	_nodal_value_old_array

MooseArray< OutputType >	_nodal_value_older_array

bool	_need_u_dot
	u dot flags More...

bool	_need_u_dotdot

bool	_need_u_dot_old

bool	_need_u_dotdot_old

bool	_need_du_dot_du

bool	_need_du_dotdot_du

bool	_need_grad_dot
	gradient dot flags More...

bool	_need_grad_dotdot

bool	_need_dof_values_dot
	local solution flags More...

bool	_need_dof_values_dotdot

bool	_need_dof_values_dot_old

bool	_need_dof_values_dotdot_old

bool	_need_dof_du_dot_du

bool	_need_dof_du_dotdot_du

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

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

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

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

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

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

OutputType	_nodal_value_dot
	nodal values of u_dot More...

OutputType	_nodal_value_dotdot
	nodal values of u_dotdot More...

OutputType	_nodal_value_dot_old
	nodal values of u_dot_old More...

OutputType	_nodal_value_dotdot_old
	nodal values of u_dotdot_old More...

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

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

Private Member Functions
void	initializeSolnVars ()

const std::vector< dof_id_type > &	initDofIndices ()
	Fetch and return the dof indices of this variable on the current element. More...

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

const libMesh::FEType &	_fe_type
	Reference to the variable's finite element type. More...

const unsigned int	_var_num
	The index of the variable in the system. More...

const Assembly &	_assembly
	Reference to the system assembly of the variable. More...

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

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

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

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

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

const libMesh::QBase *	_qrule
	Pointer to the quadrature rule. More...

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

Detailed Description

template<typename OutputType>
class MooseVariableDataLinearFV< OutputType >

Class holding the data members for linear finite volume variables.

At the moment, this is only used when the user wants to use linear finite volume variables in the postprocessor/userobject and auxiliary systems. The solver-related functionalities rely on a different machinery.

Definition at line 51 of file MooseVariableDataLinearFV.h.

Member Typedef Documentation

◆ DoFValue

template<typename OutputType >

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

Definition at line 76 of file MooseVariableDataLinearFV.h.

◆ FieldVariableCurl

template<typename OutputType >

typedef MooseArray<OutputType> MooseVariableDataLinearFV< OutputType >::FieldVariableCurl

Definition at line 63 of file MooseVariableDataLinearFV.h.

◆ FieldVariableDivergence

template<typename OutputType >

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

Definition at line 64 of file MooseVariableDataLinearFV.h.

◆ FieldVariableGradient

template<typename OutputType >

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

Definition at line 61 of file MooseVariableDataLinearFV.h.

◆ FieldVariableSecond

template<typename OutputType >

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

Definition at line 62 of file MooseVariableDataLinearFV.h.

◆ FieldVariableValue

template<typename OutputType >

typedef MooseArray<OutputType> MooseVariableDataLinearFV< OutputType >::FieldVariableValue

Definition at line 60 of file MooseVariableDataLinearFV.h.

◆ OutputData

template<typename OutputType >

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

Definition at line 75 of file MooseVariableDataLinearFV.h.

◆ OutputDivergence

template<typename OutputType >

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

Definition at line 57 of file MooseVariableDataLinearFV.h.

◆ OutputGradient

template<typename OutputType >

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

Definition at line 55 of file MooseVariableDataLinearFV.h.

◆ OutputSecond

template<typename OutputType >

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

Definition at line 56 of file MooseVariableDataLinearFV.h.

◆ OutputShape

template<typename OutputType >

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

Definition at line 67 of file MooseVariableDataLinearFV.h.

◆ OutputShapeDivergence

template<typename OutputType >

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

Definition at line 72 of file MooseVariableDataLinearFV.h.

◆ OutputShapeGradient

template<typename OutputType >

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

Definition at line 70 of file MooseVariableDataLinearFV.h.

◆ OutputShapeSecond

template<typename OutputType >

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

Definition at line 71 of file MooseVariableDataLinearFV.h.

Constructor & Destructor Documentation

◆ MooseVariableDataLinearFV()

template<typename OutputType >

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

Definition at line 33 of file MooseVariableDataLinearFV.C.

   : MooseVariableDataBase<OutputType>(var, sys, tid),
     _var(var),
     _fe_type(_var.feType()),
     _var_num(_var.number()),
     _assembly(_subproblem.assembly(_tid, var.kind() == Moose::VAR_SOLVER ? sys.number() : 0)),
     _element_type(element_type),
     _time_integrator(_sys.queryTimeIntegrator(_var_num)),
     _elem(elem),
     _displaced(dynamic_cast<const DisplacedSystem *>(&_sys) ? true : false),
     _qrule(nullptr)
 {
 }

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

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

◆ add() [2/2]

template<>

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

inherited

Definition at line 440 of file MooseVariableDataBase.C.

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

◆ assignNodalValue() [1/3]

template<typename OutputType >

void MooseVariableDataBase< OutputType >::assignNodalValue ( )

protectedinherited

Definition at line 746 of file MooseVariableDataBase.C.

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

◆ assignNodalValue() [2/3]

template<>

void MooseVariableDataBase< RealVectorValue >::assignNodalValue ( )

protectedinherited

◆ assignNodalValue() [3/3]

template<>

void MooseVariableDataBase< RealVectorValue >::assignNodalValue ( )

protectedinherited

Definition at line 783 of file MooseVariableDataBase.C.

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

◆ clearDofIndices()

template<typename OutputType >

void MooseVariableDataLinearFV< OutputType >::clearDofIndices ( )

inline

Clear the dof indices in the cache.

Definition at line 129 of file MooseVariableDataLinearFV.h.

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

◆ computeValues()

template<typename OutputType >

void MooseVariableDataLinearFV< OutputType >::computeValues ( )

Compute the variable values.

Definition at line 107 of file MooseVariableDataLinearFV.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");
 
   const auto nqp = _qrule->n_points();
   auto && active_coupleable_matrix_tags =
       _sys.subproblem().getActiveFEVariableCoupleableMatrixTags(_tid);
 
   for (const auto qp : make_range(nqp))
   {
     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];
   }
 }

◆ dofIndices()

template<typename OutputType >

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

Get the dof indices of the current element.

Definition at line 237 of file MooseVariableDataLinearFV.h.

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

◆ dofValues()

template<typename OutputType >

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

inherited

Definition at line 333 of file MooseVariableDataBase.C.

 {
   return vectorTagDofValue(Moose::Current);
 }

◆ dofValuesOld()

template<typename OutputType >

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

inherited

Definition at line 340 of file MooseVariableDataBase.C.

 {
   return vectorTagDofValue(Moose::Old);
 }

◆ dofValuesOlder()

template<typename OutputType >

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

inherited

Definition at line 347 of file MooseVariableDataBase.C.

 {
   return vectorTagDofValue(Moose::Older);
 }

◆ dofValuesPreviousNL()

template<typename OutputType >

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

inherited

Definition at line 354 of file MooseVariableDataBase.C.

 {
   return vectorTagDofValue(Moose::PreviousNL);
 }

◆ fetchDoFValues() [1/3]

template<typename OutputType >

void MooseVariableDataBase< OutputType >::fetchDoFValues ( )

protectedinherited

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

Definition at line 529 of file MooseVariableDataBase.C.

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

◆ fetchDoFValues() [2/3]

template<>

void MooseVariableDataBase< RealEigenVector >::fetchDoFValues ( )

protectedinherited

◆ fetchDoFValues() [3/3]

template<>

void MooseVariableDataBase< RealEigenVector >::fetchDoFValues ( )

protectedinherited

Definition at line 650 of file MooseVariableDataBase.C.

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

◆ getArrayDoFValues()

template<typename OutputType>

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

protectedinherited

Definition at line 618 of file MooseVariableDataBase.C.

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

◆ getContinuity()

template<typename OutputType >

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

inlineoverridevirtual

Return the variable continuity.

Implements MooseVariableDataBase< OutputType >.

Definition at line 86 of file MooseVariableDataLinearFV.h.

86 { return libMesh::DISCONTINUOUS; }

libMesh::DISCONTINUOUS

DISCONTINUOUS

◆ getDofIndices()

template<typename OutputType >

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

Get the dof indices for an element.

Parameters

elem	The element on which the dof indices shall be queried
dof_indices	The container in which the dof indices will be copied

Definition at line 165 of file MooseVariableDataLinearFV.C.

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

◆ gradSln()

template<typename OutputType >

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

inherited

Local solution gradient getter.

Parameters

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

Definition at line 312 of file MooseVariableDataBase.C.

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

◆ hasDoFsOnNodes()

template<typename OutputType >

bool MooseVariableDataLinearFV< OutputType >::hasDoFsOnNodes ( ) const

inlineoverridevirtual

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

Implements MooseVariableDataBase< OutputType >.

Definition at line 85 of file MooseVariableDataLinearFV.h.

85 { return false; }

◆ initDofIndices()

template<typename OutputType >

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

private

Fetch and return the dof indices of this variable on the current element.

Definition at line 99 of file MooseVariableDataLinearFV.C.

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

◆ initializeSolnVars()

template<typename OutputType >

void MooseVariableDataLinearFV< OutputType >::initializeSolnVars ( )

private

Definition at line 75 of file MooseVariableDataLinearFV.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);
     }
 }

◆ insert() [1/2]

template<typename OutputType>

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

inherited

Set the current local DOF values to the input vector.

Definition at line 390 of file MooseVariableDataBase.C.

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

◆ insert() [2/2]

template<>

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

inherited

Definition at line 403 of file MooseVariableDataBase.C.

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

◆ insertSolutionTag()

template<typename OutputType >

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

protectedinherited

insert a solution tag into our tag containers

Definition at line 323 of file MooseVariableDataBase.h.

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

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

◆ isNodal()

template<typename OutputType >

bool MooseVariableDataLinearFV< OutputType >::isNodal ( ) const

inlineoverridevirtual

Returns: Whether this data is associated with a nodal variable

Implements MooseVariableDataBase< OutputType >.

Definition at line 84 of file MooseVariableDataLinearFV.h.

84 { return false; }

◆ matrixTagValue()

template<typename OutputType >

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

inherited

Definition at line 219 of file MooseVariableDataBase.C.

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

◆ needSolutionState()

template<typename OutputType >

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

protectedinherited

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

Definition at line 244 of file MooseVariableDataBase.C.

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

◆ nodalMatrixTagValue()

template<typename OutputType >

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

inherited

Definition at line 116 of file MooseVariableDataBase.C.

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

◆ nodalValue()

template<typename OutputType >

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

inherited

Definition at line 466 of file MooseVariableDataBase.C.

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

◆ nodalValueArray()

template<typename OutputType >

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

inherited

Definition at line 500 of file MooseVariableDataBase.C.

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

◆ nodalVectorTagValue()

template<typename OutputType >

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

inherited

Definition at line 93 of file MooseVariableDataBase.C.

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

◆ numberOfDofs()

template<typename OutputType >

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

Get the number of dofs on the current element.

Definition at line 244 of file MooseVariableDataLinearFV.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 237 of file MooseVariableDataBase.C.

 {
   return _max_state;
 }

◆ prepareAux()

template<typename OutputType>

void MooseVariableDataBase< OutputType >::prepareAux ( )

inlineinherited

Clear aux state.

Definition at line 140 of file MooseVariableDataBase.h.

140 { _has_dof_values = false; }

MooseVariableDataBase::_has_dof_values

bool _has_dof_values

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

Definition: MooseVariableDataBase.h:199

◆ prepareIC()

template<typename OutputType>

void MooseVariableDataBase< OutputType >::prepareIC ( )

inherited

prepare the initial condition

◆ resizeVectorTagData()

template<typename OutputType >

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

protectedinherited

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

Definition at line 142 of file MooseVariableDataBase.C.

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

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

◆ setActiveTags()

template<typename OutputType >

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

inherited

Set the active vector tags.

Parameters

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

Definition at line 307 of file MooseVariableDataBase.h.

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

◆ setDofValue()

template<typename OutputType >

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

Set local DOF value at index to value .

Definition at line 141 of file MooseVariableDataLinearFV.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;
 }

◆ setDofValues()

template<typename OutputType >

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

Set local DOF values to the entries of values .

Definition at line 155 of file MooseVariableDataLinearFV.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 MooseVariableDataLinearFV< 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 54 of file MooseVariableDataLinearFV.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,
		unsigned int	idx = `0`
	)

inherited

Set nodal value.

Definition at line 361 of file MooseVariableDataBase.C.

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

◆ setNodalValue() [2/2]

template<>

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

inherited

Definition at line 377 of file MooseVariableDataBase.C.

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

◆ sln()

template<typename OutputType >

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

inherited

Local solution getter.

Parameters

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

Definition at line 301 of file MooseVariableDataBase.C.

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

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

◆ stateToTagHelper()

template<typename OutputType >

template<typename ReturnType , typename Functor >

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

protectedinherited

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

Definition at line 256 of file MooseVariableDataBase.C.

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

◆ var()

template<typename OutputType >

const MooseLinearVariableFV< OutputType > & MooseVariableDataLinearFV< OutputType >::var ( ) const

overrideprotectedvirtual

Get the corresponding variable.

Reimplemented from MooseVariableDataBase< OutputType >.

Definition at line 173 of file MooseVariableDataLinearFV.C.

 {
   return _var;
 }

◆ vectorTagDofValue() [1/2]

template<typename OutputType >

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

inherited

Definition at line 189 of file MooseVariableDataBase.C.

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

◆ vectorTagDofValue() [2/2]

template<typename OutputType >

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

inherited

Definition at line 323 of file MooseVariableDataBase.C.

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

◆ vectorTagGradient()

template<typename OutputType >

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

inherited

Definition at line 204 of file MooseVariableDataBase.C.

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

◆ vectorTagValue()

template<typename OutputType >

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

inherited

Definition at line 174 of file MooseVariableDataBase.C.

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

◆ zeroSizeDofValues()

template<typename OutputType >

void MooseVariableDataBase< OutputType >::zeroSizeDofValues ( )

protectedinherited

Definition at line 726 of file MooseVariableDataBase.C.

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

Friends And Related Function Documentation

◆ Moose::initDofIndices

template<typename OutputType >

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

friend

Member Data Documentation

◆ _assembly

template<typename OutputType >

const Assembly& MooseVariableDataLinearFV< OutputType >::_assembly

private

Reference to the system assembly of the variable.

Definition at line 154 of file MooseVariableDataLinearFV.h.

◆ _count

template<typename OutputType>

unsigned int MooseVariableDataBase< OutputType >::_count

protectedinherited

Number of components of the associated variable.

Definition at line 195 of file MooseVariableDataBase.h.

◆ _displaced

template<typename OutputType >

const bool MooseVariableDataLinearFV< OutputType >::_displaced

private

Whether this variable is being calculated on a displaced system.

Definition at line 176 of file MooseVariableDataLinearFV.h.

◆ _dof_du_dot_du

template<typename OutputType>

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

protectedinherited

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

Definition at line 274 of file MooseVariableDataBase.h.

◆ _dof_du_dotdot_du

template<typename OutputType>

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

protectedinherited

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

Definition at line 277 of file MooseVariableDataBase.h.

◆ _dof_indices

template<typename OutputType>

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

protectedinherited

The dof indices for the current element.

Definition at line 217 of file MooseVariableDataBase.h.

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

◆ _dof_map

template<typename OutputType>

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

protectedinherited

The degree of freedom map from libMesh.

Definition at line 192 of file MooseVariableDataBase.h.

◆ _dof_values_dot

template<typename OutputType>

DoFValue MooseVariableDataBase< OutputType >::_dof_values_dot

protectedinherited

time derivative of the solution values

Definition at line 266 of file MooseVariableDataBase.h.

◆ _dof_values_dot_old

template<typename OutputType>

DoFValue MooseVariableDataBase< OutputType >::_dof_values_dot_old

protectedinherited

the previous time step's solution value time derivative

Definition at line 270 of file MooseVariableDataBase.h.

◆ _dof_values_dotdot

template<typename OutputType>

DoFValue MooseVariableDataBase< OutputType >::_dof_values_dotdot

protectedinherited

second time derivative of the solution values

Definition at line 268 of file MooseVariableDataBase.h.

◆ _dof_values_dotdot_old

template<typename OutputType>

DoFValue MooseVariableDataBase< OutputType >::_dof_values_dotdot_old

protectedinherited

the previous time step's solution value second time derivative

Definition at line 272 of file MooseVariableDataBase.h.

◆ _elem

template<typename OutputType >

const Elem* const& MooseVariableDataLinearFV< 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 165 of file MooseVariableDataLinearFV.h.

◆ _element_type

template<typename OutputType >

Moose::ElementType MooseVariableDataLinearFV< OutputType >::_element_type

private

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

Definition at line 157 of file MooseVariableDataLinearFV.h.

◆ _fe_type

template<typename OutputType >

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

private

Reference to the variable's finite element type.

Definition at line 148 of file MooseVariableDataLinearFV.h.

◆ _has_dof_values

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_has_dof_values

protectedinherited

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

Definition at line 199 of file MooseVariableDataBase.h.

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

◆ _matrix_tag_u

template<typename OutputType>

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

protectedinherited

Definition at line 231 of file MooseVariableDataBase.h.

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

◆ _matrix_tags_dof_u

template<typename OutputType>

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

protectedinherited

Definition at line 225 of file MooseVariableDataBase.h.

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

◆ _max_state

template<typename OutputType>

unsigned int MooseVariableDataBase< OutputType >::_max_state

protectedinherited

The maximum number of older solution states our variable needs.

Definition at line 202 of file MooseVariableDataBase.h.

◆ _need_dof_du_dot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_du_dot_du

mutableprotectedinherited

Definition at line 262 of file MooseVariableDataBase.h.

◆ _need_dof_du_dotdot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_du_dotdot_du

mutableprotectedinherited

Definition at line 263 of file MooseVariableDataBase.h.

◆ _need_dof_values_dot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dot

mutableprotectedinherited

local solution flags

Definition at line 258 of file MooseVariableDataBase.h.

◆ _need_dof_values_dot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dot_old

mutableprotectedinherited

Definition at line 260 of file MooseVariableDataBase.h.

◆ _need_dof_values_dotdot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dotdot

mutableprotectedinherited

Definition at line 259 of file MooseVariableDataBase.h.

◆ _need_dof_values_dotdot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dotdot_old

mutableprotectedinherited

Definition at line 261 of file MooseVariableDataBase.h.

◆ _need_du_dot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_du_dot_du

mutableprotectedinherited

Definition at line 250 of file MooseVariableDataBase.h.

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

◆ _need_du_dotdot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_du_dotdot_du

mutableprotectedinherited

Definition at line 251 of file MooseVariableDataBase.h.

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

◆ _need_grad_dot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_grad_dot

mutableprotectedinherited

gradient dot flags

Definition at line 254 of file MooseVariableDataBase.h.

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

◆ _need_grad_dotdot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_grad_dotdot

mutableprotectedinherited

Definition at line 255 of file MooseVariableDataBase.h.

◆ _need_matrix_tag_dof_u

template<typename OutputType>

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

mutableprotectedinherited

Definition at line 220 of file MooseVariableDataBase.h.

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

◆ _need_matrix_tag_u

template<typename OutputType>

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

mutableprotectedinherited

Definition at line 232 of file MooseVariableDataBase.h.

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

◆ _need_u_dot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_u_dot

mutableprotectedinherited

u dot flags

Definition at line 246 of file MooseVariableDataBase.h.

◆ _need_u_dot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_u_dot_old

mutableprotectedinherited

Definition at line 248 of file MooseVariableDataBase.h.

◆ _need_u_dotdot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_u_dotdot

mutableprotectedinherited

Definition at line 247 of file MooseVariableDataBase.h.

◆ _need_u_dotdot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_u_dotdot_old

mutableprotectedinherited

Definition at line 249 of file MooseVariableDataBase.h.

◆ _need_vector_tag_dof_u

template<typename OutputType>

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

mutableprotectedinherited

Definition at line 219 of file MooseVariableDataBase.h.

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

◆ _need_vector_tag_grad

template<typename OutputType>

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

mutableprotectedinherited

Definition at line 230 of file MooseVariableDataBase.h.

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

◆ _need_vector_tag_u

template<typename OutputType>

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

mutableprotectedinherited

Definition at line 228 of file MooseVariableDataBase.h.

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

◆ _nodal_value

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value

protectedinherited

Nodal values.

Definition at line 235 of file MooseVariableDataBase.h.

◆ _nodal_value_array

template<typename OutputType>

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_array

protectedinherited

Nodal values as MooseArrays for use with AuxKernels.

Definition at line 241 of file MooseVariableDataBase.h.

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

◆ _nodal_value_dot

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_dot

protectedinherited

nodal values of u_dot

Definition at line 280 of file MooseVariableDataBase.h.

◆ _nodal_value_dot_old

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_dot_old

protectedinherited

nodal values of u_dot_old

Definition at line 284 of file MooseVariableDataBase.h.

◆ _nodal_value_dotdot

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_dotdot

protectedinherited

nodal values of u_dotdot

Definition at line 282 of file MooseVariableDataBase.h.

◆ _nodal_value_dotdot_old

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_dotdot_old

protectedinherited

nodal values of u_dotdot_old

Definition at line 286 of file MooseVariableDataBase.h.

◆ _nodal_value_old

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_old

protectedinherited

Definition at line 236 of file MooseVariableDataBase.h.

◆ _nodal_value_old_array

template<typename OutputType>

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_old_array

protectedinherited

Definition at line 242 of file MooseVariableDataBase.h.

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

◆ _nodal_value_older

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_older

protectedinherited

Definition at line 237 of file MooseVariableDataBase.h.

◆ _nodal_value_older_array

template<typename OutputType>

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_older_array

protectedinherited

Definition at line 243 of file MooseVariableDataBase.h.

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

◆ _nodal_value_previous_nl

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value_previous_nl

protectedinherited

Definition at line 238 of file MooseVariableDataBase.h.

◆ _old_solution_tag

template<typename OutputType>

TagID MooseVariableDataBase< OutputType >::_old_solution_tag

protectedinherited

The vector tag ID corresponding to the old solution vector.

Definition at line 208 of file MooseVariableDataBase.h.

◆ _older_solution_tag

template<typename OutputType>

TagID MooseVariableDataBase< OutputType >::_older_solution_tag

protectedinherited

The vector tag ID corresponding to the older solution vector.

Definition at line 211 of file MooseVariableDataBase.h.

◆ _prev_elem

template<typename OutputType >

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

mutableprivate

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

Definition at line 168 of file MooseVariableDataLinearFV.h.

Referenced by MooseVariableDataLinearFV< 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 214 of file MooseVariableDataBase.h.

◆ _qrule

template<typename OutputType >

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

private

Pointer to the quadrature rule.

Definition at line 179 of file MooseVariableDataLinearFV.h.

◆ _required_vector_tags

template<typename OutputType>

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

protectedinherited

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

Definition at line 289 of file MooseVariableDataBase.h.

◆ _solution_tag

template<typename OutputType>

TagID MooseVariableDataBase< OutputType >::_solution_tag

protectedinherited

The vector tag ID corresponding to the solution vector.

Definition at line 205 of file MooseVariableDataBase.h.

◆ _solution_tags

template<typename OutputType>

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

protectedinherited

The set of solution tags we need to evaluate.

Definition at line 292 of file MooseVariableDataBase.h.

◆ _subproblem

template<typename OutputType>

const SubProblem& MooseVariableDataBase< OutputType >::_subproblem

protectedinherited

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

Definition at line 186 of file MooseVariableDataBase.h.

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

◆ _sys

template<typename OutputType>

SystemBase& MooseVariableDataBase< OutputType >::_sys

protectedinherited

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

Definition at line 183 of file MooseVariableDataBase.h.

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

◆ _tid

template<typename OutputType>

const THREAD_ID MooseVariableDataBase< OutputType >::_tid

protectedinherited

The thread ID that this object is on.

Definition at line 189 of file MooseVariableDataBase.h.

◆ _time_integrator

template<typename OutputType >

const TimeIntegrator* const MooseVariableDataLinearFV< OutputType >::_time_integrator

private

Pointer to time integrator.

Definition at line 160 of file MooseVariableDataLinearFV.h.

◆ _var

template<typename OutputType >

const MooseLinearVariableFV<OutputType>& MooseVariableDataLinearFV< OutputType >::_var

private

A const reference to the owning MooseLinearVariableFV object.

Definition at line 145 of file MooseVariableDataLinearFV.h.

◆ _var_num

template<typename OutputType >

const unsigned int MooseVariableDataLinearFV< OutputType >::_var_num

private

The index of the variable in the system.

Definition at line 151 of file MooseVariableDataLinearFV.h.

◆ _vector_tag_grad

template<typename OutputType>

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

protectedinherited

Definition at line 229 of file MooseVariableDataBase.h.

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

◆ _vector_tag_u

template<typename OutputType>

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

protectedinherited

Definition at line 227 of file MooseVariableDataBase.h.

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

◆ _vector_tags_dof_u

template<typename OutputType>

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

protectedinherited

Definition at line 223 of file MooseVariableDataBase.h.

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

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

include/variables/MooseVariableDataLinearFV.h
src/variables/MooseVariableDataLinearFV.C

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Friends

Detailed Description

template<typename OutputType> class MooseVariableDataLinearFV< OutputType >

Member Typedef Documentation

◆ DoFValue

◆ FieldVariableCurl

◆ FieldVariableDivergence

◆ FieldVariableGradient

◆ FieldVariableSecond

◆ FieldVariableValue

◆ OutputData

◆ OutputDivergence

◆ OutputGradient

◆ OutputSecond

◆ OutputShape

◆ OutputShapeDivergence

◆ OutputShapeGradient

◆ OutputShapeSecond

Constructor & Destructor Documentation

◆ MooseVariableDataLinearFV()

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ assignNodalValue() [1/3]

◆ assignNodalValue() [2/3]

◆ assignNodalValue() [3/3]

◆ clearDofIndices()

◆ computeValues()

◆ dofIndices()

◆ dofValues()

◆ dofValuesOld()

◆ dofValuesOlder()

◆ dofValuesPreviousNL()

◆ fetchDoFValues() [1/3]

◆ fetchDoFValues() [2/3]

◆ fetchDoFValues() [3/3]

◆ getArrayDoFValues()

◆ getContinuity()

◆ getDofIndices()

◆ gradSln()

◆ hasDoFsOnNodes()

◆ initDofIndices()

◆ initializeSolnVars()

◆ insert() [1/2]

◆ insert() [2/2]

◆ insertSolutionTag()

◆ isNodal()

◆ matrixTagValue()

◆ needSolutionState()

◆ nodalMatrixTagValue()

◆ nodalValue()

◆ nodalValueArray()

◆ nodalVectorTagValue()

◆ numberOfDofs()

◆ oldestSolutionStateRequested()

◆ prepareAux()

◆ prepareIC()

◆ resizeVectorTagData()

◆ setActiveTags()

◆ setDofValue()

◆ setDofValues()

◆ setGeometry()

◆ setNodalValue() [1/2]

◆ setNodalValue() [2/2]

◆ sln()

◆ stateToTagHelper()

◆ var()

◆ vectorTagDofValue() [1/2]

◆ vectorTagDofValue() [2/2]

◆ vectorTagGradient()

◆ vectorTagValue()

◆ zeroSizeDofValues()

Friends And Related Function Documentation

◆ Moose::initDofIndices

template<typename OutputType>
class MooseVariableDataLinearFV< OutputType >