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	DofValue

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

typedef MooseArray< DofValue >	DofValues

typedef MooseArray< ADDofValue >	ADDofValues

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.

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

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

void	computeValues ()
	Compute the variable values.

void	prepareIC ()
	Prepare the initial condition: initialize DOF indices and resize the DOF value array.

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

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

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

void	fetchDofValues ()

void	fetchDofValues ()

void	zeroSizeDofValues ()

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

void	assignNodalValue ()

void	assignNodalValue ()

void	assignNodalValue ()

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

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

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

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

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

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

unsigned int	_count
	Number of components of the associated variable.

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

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

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

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

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

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

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

std::vector< bool >	_need_vector_tag_dof_u

std::vector< bool >	_need_matrix_tag_dof_u

std::vector< DofValues >	_vector_tags_dof_u

std::vector< DofValues >	_matrix_tags_dof_u

std::vector< FieldVariableValue >	_vector_tag_u

std::vector< bool >	_need_vector_tag_u

std::vector< FieldVariableGradient >	_vector_tag_grad

std::vector< bool >	_need_vector_tag_grad

std::vector< FieldVariableValue >	_matrix_tag_u

std::vector< bool >	_need_matrix_tag_u

OutputType	_nodal_value
	Nodal values.

OutputType	_nodal_value_old

OutputType	_nodal_value_older

OutputType	_nodal_value_previous_nl

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

MooseArray< OutputType >	_nodal_value_old_array

MooseArray< OutputType >	_nodal_value_older_array

bool	_need_u_dot
	u dot flags

bool	_need_u_dotdot

bool	_need_u_dot_old

bool	_need_u_dotdot_old

bool	_need_du_dot_du

bool	_need_du_dotdot_du

bool	_need_grad_dot
	gradient dot flags

bool	_need_grad_dotdot

bool	_need_dof_values_dot
	local solution flags

bool	_need_dof_values_dotdot

bool	_need_dof_values_dot_old

bool	_need_dof_values_dotdot_old

bool	_need_dof_du_dot_du

bool	_need_dof_du_dotdot_du

DofValues	_dof_values_dot
	time derivative of the solution values

DofValues	_dof_values_dotdot
	second time derivative of the solution values

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

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

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

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

OutputType	_nodal_value_dot
	nodal values of u_dot

OutputType	_nodal_value_dotdot
	nodal values of u_dotdot

OutputType	_nodal_value_dot_old
	nodal values of u_dot_old

OutputType	_nodal_value_dotdot_old
	nodal values of u_dotdot_old

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

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

Private Member Functions
void	initializeSolnVars ()

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

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

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

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

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

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

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

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

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

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

◆ ADDofValue

template<typename OutputType >

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

inherited

Definition at line 47 of file MooseVariableDataBase.h.

◆ ADDofValues

template<typename OutputType >

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

inherited

Definition at line 49 of file MooseVariableDataBase.h.

◆ DofValue

template<typename OutputType >

typedef Moose::DOFType<OutputType>::type MooseVariableDataBase< OutputType >::DofValue

inherited

Definition at line 46 of file MooseVariableDataBase.h.

◆ DofValues

template<typename OutputType >

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

inherited

Definition at line 48 of file MooseVariableDataBase.h.

◆ FieldVariableCurl

template<typename OutputType >

typedef MooseArray<OutputType> 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.

◆ 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 441 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 452 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));
    }
  }
}

◆ assignNodalValue() [1/3]

template<typename OutputType >

void MooseVariableDataBase< OutputType >::assignNodalValue ( )

protectedinherited

Definition at line 736 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 772 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 133 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 108 of file MooseVariableDataLinearFV.C.

{
  getDofIndices(_elem, _dof_indices);
  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 241 of file MooseVariableDataLinearFV.h.

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

◆ dofValues()

template<typename OutputType >

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

inherited

Definition at line 352 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Current);
}

◆ dofValuesOld()

template<typename OutputType >

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

inherited

Definition at line 359 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Old);
}

◆ dofValuesOlder()

template<typename OutputType >

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

inherited

Definition at line 366 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Older);
}

◆ dofValuesPreviousNL()

template<typename OutputType >

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

inherited

Definition at line 373 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 534 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 637 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 622 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 MooseVariableDataLinearFV< OutputType >::getContinuity ( ) const

inlineoverridevirtual

Return the variable continuity.

Implements MooseVariableDataBase< OutputType >.

Definition at line 85 of file MooseVariableDataLinearFV.h.

85{ 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 174 of file MooseVariableDataLinearFV.C.

{
  // Avoid calling the dof map routine (for performance)
  const auto n_dofs = elem->n_dofs(_sys.number(), _var_num);
  if (n_dofs)
  {
    mooseAssert(n_dofs == 1, "Should be just one dof");
    dof_indices.resize(1);
    dof_indices[0] = elem->dof_number(_sys.number(), _var_num, 0);
  }
  else
    dof_indices.clear();
}

◆ 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 327 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);
}

◆ 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 84 of file MooseVariableDataLinearFV.h.

84{ 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.

{
  // We might not have a valid element, so we don't use the element to get the dof
  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 409 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 422 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 MooseVariableDataLinearFV< OutputType >::isNodal ( ) const

inlineoverridevirtual

Returns: Whether this data is associated with a nodal variable

Implements MooseVariableDataBase< OutputType >.

Definition at line 83 of file MooseVariableDataLinearFV.h.

83{ return false; }

◆ matrixTagValue()

template<typename OutputType >

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

inherited

Definition at line 230 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());
}

◆ 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 257 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 121 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 471 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 505 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 98 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 248 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 250 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 MooseVariableDataLinearFV< OutputType >::prepareIC ( )

Prepare the initial condition: initialize DOF indices and resize the DOF value array.

Definition at line 142 of file MooseVariableDataLinearFV.C.

{
  initDofIndices();
  _vector_tags_dof_u[_solution_tag].resize(_dof_indices.size());
}

◆ 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 147 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);
}

◆ 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 MooseVariableDataLinearFV< OutputType >::setDofValue	(	const DofValue &	value,
		unsigned int	index
	)

Set local DOF value at index to value .

Definition at line 150 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< DofValue > & values )

Set local DOF values to the entries of values .

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

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

inherited

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

◆ sizeMatrixTagData()

template<typename OutputType >

void MooseVariableDataBase< OutputType >::sizeMatrixTagData ( )

inherited

size matrix tag data

Definition at line 85 of file MooseVariableDataBase.C.

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

◆ sln()

template<typename OutputType >

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

inherited

Local solution getter.

Parameters

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

Definition at line 314 of file MooseVariableDataBase.C.

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

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

◆ stateToTagHelper()

template<typename OutputType >

template<typename ReturnType , typename Functor >

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

protectedinherited

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

Definition at line 269 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 191 of file MooseVariableDataLinearFV.C.

{
  return _var;
}

◆ vectorTagDofValue() [1/2]

template<typename OutputType >

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

inherited

Definition at line 340 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 196 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 213 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 179 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 716 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	(	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 158 of file MooseVariableDataLinearFV.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.

◆ _displaced

template<typename OutputType >

const bool MooseVariableDataLinearFV< OutputType >::_displaced

private

Whether this variable is being calculated on a displaced system.

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

◆ _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 169 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 161 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 152 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 206 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 238 of file MooseVariableDataBase.h.

◆ _matrix_tags_dof_u

template<typename OutputType >

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

protectedinherited

Definition at line 232 of file MooseVariableDataBase.h.

◆ _max_state

template<typename OutputType >

unsigned int MooseVariableDataBase< OutputType >::_max_state

protectedinherited

The maximum number of older solution states our variable needs.

Definition at line 209 of file MooseVariableDataBase.h.

◆ _need_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_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* MooseVariableDataLinearFV< OutputType >::_prev_elem = nullptr

mutableprivate

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

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

◆ _qrule

template<typename OutputType >

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

private

Pointer to the quadrature rule.

Definition at line 183 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 296 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 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 MooseVariableDataLinearFV< OutputType >::_time_integrator

private

Pointer to time integrator.

Definition at line 164 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 149 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 155 of file MooseVariableDataLinearFV.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/MooseVariableDataLinearFV.h
src/variables/MooseVariableDataLinearFV.C

Public Types

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

◆ 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]

◆ sizeMatrixTagData()

◆ sln()

◆ stateToTagHelper()

◆ var()

◆ vectorTagDofValue() [1/2]

◆ vectorTagDofValue() [2/2]

◆ vectorTagGradient()

◆ vectorTagValue()

◆ zeroSizeDofValues()