MooseVariableDataBase< OutputType > Class Template Reference

#include <MooseVariableDataBase.h>

Inheritance diagram for MooseVariableDataBase< 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 Moose::DOFType< OutputType >::type	OutputData
typedef MooseArray< OutputData >	DoFValue

Public Member Functions
	MooseVariableDataBase (const MooseVariableField< OutputType > &var, SystemBase &sys, THREAD_ID tid)
virtual	~MooseVariableDataBase ()=default
virtual bool	isNodal () const =0
virtual bool	hasDoFsOnNodes () const =0
	Whether this data is associated with a variable that has DoFs on nodes. More...
virtual libMesh::FEContinuity	getContinuity () const =0
	Return the variable continuity. 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...
void	insert (libMesh::NumericVector< libMesh::Number > &residual)
	Set the current local DOF values to the input vector. More...
void	add (libMesh::NumericVector< libMesh::Number > &residual)
	Add the current local DOF values to the input vector. More...
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...
template<>
void	setNodalValue (const RealVectorValue &value, unsigned int idx)
template<>
void	insert (NumericVector< Number > &residual)
template<>
void	add (NumericVector< Number > &residual)

Protected Member Functions
virtual const MooseVariableField< OutputType > &	var () const
void	insertSolutionTag (TagID tag_id)
	insert a solution tag into our tag containers More...
void	needSolutionState (unsigned int state)
	Request that we have at least state number of older solution states/vectors. More...
void	fetchDoFValues ()
	Helper methods for assigning dof values from their corresponding solution values. More...
void	zeroSizeDofValues ()
void	getArrayDoFValues (const libMesh::NumericVector< libMesh::Number > &sol, unsigned int n, MooseArray< RealEigenVector > &dof_values) const
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...
template<>
void	fetchDoFValues ()
template<>
void	assignNodalValue ()
template<>
void	fetchDoFValues ()
template<>
void	assignNodalValue ()

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 Attributes
const MooseVariableField< OutputType > &	_var
	A const reference to the owning MooseVariableField object. More...

Detailed Description

template<typename OutputType>
class MooseVariableDataBase< OutputType >

Definition at line 33 of file MooseVariableDataBase.h.

Member Typedef Documentation

DoFValue

template<typename OutputType>

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

Definition at line 47 of file MooseVariableDataBase.h.

FieldVariableGradient

template<typename OutputType>

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

Definition at line 43 of file MooseVariableDataBase.h.

FieldVariableValue

template<typename OutputType>

typedef MooseArray<OutputType> MooseVariableDataBase< OutputType >::FieldVariableValue

Definition at line 42 of file MooseVariableDataBase.h.

OutputData

template<typename OutputType>

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

Definition at line 46 of file MooseVariableDataBase.h.

OutputDivergence

template<typename OutputType>

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

Definition at line 39 of file MooseVariableDataBase.h.

OutputGradient

template<typename OutputType>

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

Definition at line 37 of file MooseVariableDataBase.h.

OutputSecond

template<typename OutputType>

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

Definition at line 38 of file MooseVariableDataBase.h.

Constructor & Destructor Documentation

MooseVariableDataBase()

template<typename OutputType >

MooseVariableDataBase< OutputType >::MooseVariableDataBase	(	const MooseVariableField< OutputType > &	var,
		SystemBase &	sys,
		THREAD_ID	tid
	)

Definition at line 18 of file MooseVariableDataBase.C.

  : _sys(sys),
    _subproblem(_sys.subproblem()),
    _tid(tid),
    _dof_map(_sys.dofMap()),
    _count(var.count()),
    _has_dof_values(false),
    _max_state(0),
    _solution_tag(_subproblem.getVectorTagID(Moose::SOLUTION_TAG)),
    _old_solution_tag(Moose::INVALID_TAG_ID),
    _older_solution_tag(Moose::INVALID_TAG_ID),
    _previous_nl_solution_tag(Moose::INVALID_TAG_ID),
    _need_u_dot(false),
    _need_u_dotdot(false),
    _need_u_dot_old(false),
    _need_u_dotdot_old(false),
    _need_du_dot_du(false),
    _need_du_dotdot_du(false),
    _need_grad_dot(false),
    _need_grad_dotdot(false),
    _need_dof_values_dot(false),
    _need_dof_values_dotdot(false),
    _need_dof_values_dot_old(false),
    _need_dof_values_dotdot_old(false),
    _need_dof_du_dot_du(false),
    _need_dof_du_dotdot_du(false),
    _var(var)
{
  auto num_vector_tags = _subproblem.numVectorTags();
  // Additional solution tags corresponding to older-than-current solution states may be requested
  // on-the-fly by consumer objects after variable construction. To accomodate this we should
  // reserve the possibly requisite memory. As of now we only support old and older solution states
  // but this could potentially increase in the future
  const auto max_future_num_vector_tags = num_vector_tags + 2;

  _vector_tags_dof_u.reserve(max_future_num_vector_tags);
  _vector_tags_dof_u.resize(num_vector_tags);
  _need_vector_tag_dof_u.reserve(max_future_num_vector_tags);
  _need_vector_tag_dof_u.resize(num_vector_tags, false);

  _need_vector_tag_u.reserve(max_future_num_vector_tags);
  _need_vector_tag_u.resize(num_vector_tags, false);
  _vector_tag_u.reserve(max_future_num_vector_tags);
  _vector_tag_u.resize(num_vector_tags);

  _need_vector_tag_grad.reserve(max_future_num_vector_tags);
  _need_vector_tag_grad.resize(num_vector_tags, false);
  _vector_tag_grad.reserve(max_future_num_vector_tags);
  _vector_tag_grad.resize(num_vector_tags);

  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);

  // Always fetch the dof values for the solution tag
  const auto soln_tag = _subproblem.getVectorTagID(Moose::SOLUTION_TAG);
  _need_vector_tag_dof_u[soln_tag] = true;
  _need_vector_tag_u[soln_tag] = true;
  insertSolutionTag(soln_tag);

  // These MooseArray objects are used by AuxKernelBase for nodal AuxKernel objects, hence the size
  // size is always 1 (i.e, nodal kernels work with _qp=0 only).
  _nodal_value_array.resize(1);
  _nodal_value_old_array.resize(1);
  _nodal_value_older_array.resize(1);
}

~MooseVariableDataBase()

template<typename OutputType>

virtual MooseVariableDataBase< OutputType >::~MooseVariableDataBase ( )

virtualdefault

Member Function Documentation

add() [1/2]

template<typename OutputType>

void MooseVariableDataBase< OutputType >::add

(

libMesh::NumericVector< libMesh::Number > &

residual

)

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

)

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

protected

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

protected

assignNodalValue() [3/3]

template<>

void MooseVariableDataBase< RealVectorValue >::assignNodalValue ( )

protected

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];
  }
}

dofValues()

template<typename OutputType >

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

(

)

const

Definition at line 333 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Current);
}

dofValuesOld()

template<typename OutputType >

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

(

)

const

Definition at line 340 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Old);
}

dofValuesOlder()

template<typename OutputType >

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

(

)

const

Definition at line 347 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::Older);
}

dofValuesPreviousNL()

template<typename OutputType >

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

(

)

const

Definition at line 354 of file MooseVariableDataBase.C.

{
  return vectorTagDofValue(Moose::PreviousNL);
}

fetchDoFValues() [1/3]

template<typename OutputType >

void MooseVariableDataBase< OutputType >::fetchDoFValues ( )

protected

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

protected

fetchDoFValues() [3/3]

template<>

void MooseVariableDataBase< RealEigenVector >::fetchDoFValues ( )

protected

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

protected

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>

virtual libMesh::FEContinuity MooseVariableDataBase< OutputType >::getContinuity ( ) const

pure virtual

Return the variable continuity.

Implemented in MooseVariableData< OutputType >, MooseVariableDataFV< OutputType >, and MooseVariableDataLinearFV< OutputType >.

gradSln()

template<typename OutputType >

const MooseVariableDataBase< OutputType >::FieldVariableGradient & MooseVariableDataBase< OutputType >::gradSln

(

Moose::SolutionState

state

)

const

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>

virtual bool MooseVariableDataBase< OutputType >::hasDoFsOnNodes ( ) const

pure virtual

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

Implemented in MooseVariableData< OutputType >, MooseVariableDataFV< OutputType >, and MooseVariableDataLinearFV< OutputType >.

insert() [1/2]

template<typename OutputType>

void MooseVariableDataBase< OutputType >::insert

(

libMesh::NumericVector< libMesh::Number > &

residual

)

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

)

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 )

protected

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>

virtual bool MooseVariableDataBase< OutputType >::isNodal ( ) const

pure virtual

Returns

Whether this data is associated with a nodal variable

Implemented in MooseVariableData< OutputType >, MooseVariableDataFV< OutputType >, and MooseVariableDataLinearFV< OutputType >.

matrixTagValue()

template<typename OutputType >

const MooseVariableDataBase< OutputType >::FieldVariableValue & MooseVariableDataBase< OutputType >::matrixTagValue

(

TagID

tag

)

const

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 )

protected

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

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

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

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

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

oldestSolutionStateRequested()

template<typename OutputType >

unsigned int MooseVariableDataBase< OutputType >::oldestSolutionStateRequested

(

)

const

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

inline

Clear aux state.

Definition at line 140 of file MooseVariableDataBase.h.

{ _has_dof_values = false; }

prepareIC()

template<typename OutputType>

void MooseVariableDataBase< OutputType >::prepareIC

(

)

prepare the initial condition

resizeVectorTagData()

template<typename OutputType >

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

protected

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

)

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

setNodalValue() [1/2]

template<typename OutputType >

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

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
	)

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

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  )

protected

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>

virtual const MooseVariableField<OutputType>& MooseVariableDataBase< OutputType >::var ( ) const

inlineprotectedvirtual

Returns

The variable to which the data in this class belongs to

Reimplemented in MooseVariableDataFV< OutputType >, and MooseVariableDataLinearFV< OutputType >.

Definition at line 146 of file MooseVariableDataBase.h.

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

{ return _var; }

vectorTagDofValue() [1/2]

template<typename OutputType >

const MooseVariableDataBase< OutputType >::DoFValue & MooseVariableDataBase< OutputType >::vectorTagDofValue

(

TagID

tag

)

const

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

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

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

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

protected

Definition at line 726 of file MooseVariableDataBase.C.

{
  if (_subproblem.isTransient())
  {
    _dof_values_dot.resize(0);
    _dof_values_dotdot.resize(0);
    _dof_values_dot_old.resize(0);
    _dof_values_dotdot_old.resize(0);
    _dof_du_dot_du.resize(0);
    _dof_du_dotdot_du.resize(0);
  }

  for (auto & dof_values : _vector_tags_dof_u)
    dof_values.resize(0);

  _has_dof_values = false;
}

Member Data Documentation

_count

template<typename OutputType>

unsigned int MooseVariableDataBase< OutputType >::_count

protected

Number of components of the associated variable.

Definition at line 195 of file MooseVariableDataBase.h.

_dof_du_dot_du

template<typename OutputType>

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

protected

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

protected

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

protected

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

protected

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

protected

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

protected

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

protected

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

protected

the previous time step's solution value second time derivative

Definition at line 272 of file MooseVariableDataBase.h.

_has_dof_values

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_has_dof_values

protected

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

protected

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

protected

Definition at line 225 of file MooseVariableDataBase.h.

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

_max_state

template<typename OutputType>

unsigned int MooseVariableDataBase< OutputType >::_max_state

protected

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

mutableprotected

Definition at line 262 of file MooseVariableDataBase.h.

_need_dof_du_dotdot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_du_dotdot_du

mutableprotected

Definition at line 263 of file MooseVariableDataBase.h.

_need_dof_values_dot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dot

mutableprotected

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

mutableprotected

Definition at line 260 of file MooseVariableDataBase.h.

_need_dof_values_dotdot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dotdot

mutableprotected

Definition at line 259 of file MooseVariableDataBase.h.

_need_dof_values_dotdot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_dof_values_dotdot_old

mutableprotected

Definition at line 261 of file MooseVariableDataBase.h.

_need_du_dot_du

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_du_dot_du

mutableprotected

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

mutableprotected

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

mutableprotected

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

mutableprotected

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

mutableprotected

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

mutableprotected

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

mutableprotected

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

mutableprotected

Definition at line 248 of file MooseVariableDataBase.h.

_need_u_dotdot

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_u_dotdot

mutableprotected

Definition at line 247 of file MooseVariableDataBase.h.

_need_u_dotdot_old

template<typename OutputType>

bool MooseVariableDataBase< OutputType >::_need_u_dotdot_old

mutableprotected

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

mutableprotected

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

mutableprotected

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

mutableprotected

Definition at line 228 of file MooseVariableDataBase.h.

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

_nodal_value

template<typename OutputType>

OutputType MooseVariableDataBase< OutputType >::_nodal_value

protected

Nodal values.

Definition at line 235 of file MooseVariableDataBase.h.

_nodal_value_array

template<typename OutputType>

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_array

protected

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

protected

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

protected

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

protected

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

protected

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

protected

Definition at line 236 of file MooseVariableDataBase.h.

_nodal_value_old_array

template<typename OutputType>

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_old_array

protected

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

protected

Definition at line 237 of file MooseVariableDataBase.h.

_nodal_value_older_array

template<typename OutputType>

MooseArray<OutputType> MooseVariableDataBase< OutputType >::_nodal_value_older_array

protected

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

protected

Definition at line 238 of file MooseVariableDataBase.h.

_old_solution_tag

template<typename OutputType>

TagID MooseVariableDataBase< OutputType >::_old_solution_tag

protected

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

protected

The vector tag ID corresponding to the older solution vector.

Definition at line 211 of file MooseVariableDataBase.h.

_previous_nl_solution_tag

template<typename OutputType>

TagID MooseVariableDataBase< OutputType >::_previous_nl_solution_tag

protected

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

Definition at line 214 of file MooseVariableDataBase.h.

_required_vector_tags

template<typename OutputType>

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

protected

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

protected

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

protected

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

protected

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

protected

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

protected

The thread ID that this object is on.

Definition at line 189 of file MooseVariableDataBase.h.

_var

template<typename OutputType>

const MooseVariableField<OutputType>& MooseVariableDataBase< OutputType >::_var

private

A const reference to the owning MooseVariableField object.

Definition at line 296 of file MooseVariableDataBase.h.

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

_vector_tag_grad

template<typename OutputType>

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

protected

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

protected

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

protected

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/MooseVariableDataBase.h
• src/variables/MooseVariableDataBase.C