MooseVariableDataBase.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#include "MooseVariableDataBase.h"
#include "MooseError.h"
#include "MooseTypes.h"
#include "SystemBase.h"
#include "SubProblem.h"
#include "MooseVariableField.h"
#include "MooseMesh.h"
#include "libmesh/mesh_base.h"
 
template <typename OutputType>
MooseVariableDataBase<OutputType>::MooseVariableDataBase(const MooseVariableField<OutputType> & var,
                                                         SystemBase & sys,
                                                         THREAD_ID tid)
  : _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);
 
  // 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);
}
 
template <typename OutputType>
void
MooseVariableDataBase<OutputType>::sizeMatrixTagData()
{
  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);
}
 
template <typename OutputType>
const typename MooseVariableDataBase<OutputType>::DofValues &
MooseVariableDataBase<OutputType>::nodalVectorTagValue(TagID tag) const
{
  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.");
}
 
template <typename OutputType>
const typename MooseVariableDataBase<OutputType>::DofValues &
MooseVariableDataBase<OutputType>::nodalMatrixTagValue(TagID tag) const
{
  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.");
}
 
template <typename OutputType>
void
MooseVariableDataBase<OutputType>::resizeVectorTagData(TagID tag)
{
  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);
}
 
template <typename OutputType>
const typename MooseVariableDataBase<OutputType>::FieldVariableValue &
MooseVariableDataBase<OutputType>::vectorTagValue(TagID tag) const
{
  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());
}
 
template <typename OutputType>
const typename MooseVariableDataBase<OutputType>::DofValues &
MooseVariableDataBase<OutputType>::vectorTagDofValue(TagID tag) const
{
  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());
}
 
template <typename OutputType>
const typename MooseVariableDataBase<OutputType>::FieldVariableGradient &
MooseVariableDataBase<OutputType>::vectorTagGradient(TagID tag) const
{
  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());
}
 
template <typename OutputType>
const typename MooseVariableDataBase<OutputType>::FieldVariableValue &
MooseVariableDataBase<OutputType>::matrixTagValue(TagID tag) const
{
  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());
}
 
template <typename OutputType>
unsigned int
MooseVariableDataBase<OutputType>::oldestSolutionStateRequested() const
{
  return _max_state;
}
 
template <typename OutputType>
void
MooseVariableDataBase<OutputType>::needSolutionState(const unsigned int state)
{
  if (state > _max_state)
  {
    _sys.needSolutionState(state);
    _max_state = state;
  }
}
 
template <typename OutputType>
template <typename ReturnType, typename Functor>
const ReturnType &
MooseVariableDataBase<OutputType>::stateToTagHelper(const Moose::SolutionState state,
                                                    Functor functor)
{
  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!");
  }
}
 
template <typename OutputType>
const typename MooseVariableDataBase<OutputType>::FieldVariableValue &
MooseVariableDataBase<OutputType>::sln(Moose::SolutionState state) const
{
  auto functor = [this](TagID tag_id) -> const FieldVariableValue &
  { return vectorTagValue(tag_id); };
 
  _var.requireQpComputations();
 
  return const_cast<MooseVariableDataBase<OutputType> *>(this)
      ->stateToTagHelper<FieldVariableValue>(state, functor);
}
 
template <typename OutputType>
const typename MooseVariableDataBase<OutputType>::FieldVariableGradient &
MooseVariableDataBase<OutputType>::gradSln(Moose::SolutionState state) const
{
  auto functor = [this](TagID tag_id) -> const FieldVariableGradient &
  { return vectorTagGradient(tag_id); };
 
  _var.requireQpComputations();
 
  return const_cast<MooseVariableDataBase<OutputType> *>(this)
      ->stateToTagHelper<FieldVariableGradient>(state, functor);
}
 
template <typename OutputType>
const typename MooseVariableDataBase<OutputType>::DofValues &
MooseVariableDataBase<OutputType>::vectorTagDofValue(Moose::SolutionState state) const
{
  auto functor = [this](TagID tag_id) -> const DofValues & { return vectorTagDofValue(tag_id); };
 
  _var.requireQpComputations();
 
  return const_cast<MooseVariableDataBase<OutputType> *>(this)->stateToTagHelper<DofValues>(
      state, functor);
}
 
template <typename OutputType>
const typename MooseVariableDataBase<OutputType>::DofValues &
MooseVariableDataBase<OutputType>::dofValues() const
{
  return vectorTagDofValue(Moose::Current);
}
 
template <typename OutputType>
const typename MooseVariableDataBase<OutputType>::DofValues &
MooseVariableDataBase<OutputType>::dofValuesOld() const
{
  return vectorTagDofValue(Moose::Old);
}
 
template <typename OutputType>
const typename MooseVariableDataBase<OutputType>::DofValues &
MooseVariableDataBase<OutputType>::dofValuesOlder() const
{
  return vectorTagDofValue(Moose::Older);
}
 
template <typename OutputType>
const typename MooseVariableDataBase<OutputType>::DofValues &
MooseVariableDataBase<OutputType>::dofValuesPreviousNL() const
{
  return vectorTagDofValue(Moose::PreviousNL);
}
 
template <typename OutputType>
void
MooseVariableDataBase<OutputType>::setNodalValue(const OutputType & value)
{
  // dof_values here is indexed per shape function, with each entry holding all _count array
  // components packed into a single OutputType value. setNodalValue writes only one shape
  // function's value, so it is only valid for a variable with a single shape function, e.g. a
  // nodal Lagrange variable or a CONSTANT-order elemental variable; a variable with more than
  // one shape function must use setDofValues instead. A subparametric variable, e.g. the pressure
  // of a Taylor-Hood pair, has nodes on its elements that carry none of its degrees of freedom;
  // callers query isNodalDefined() to skip those nodes before reaching this method.
  mooseAssert(_dof_indices.size() == _count,
              "setNodalValue is only valid for a variable with one shape function per node");
  auto & dof_values = _vector_tags_dof_u[_solution_tag];
  dof_values.resize(/*n_shapes=*/1);
  dof_values[0] = value; // update variable nodal value
  _has_dof_values = true;
  _nodal_value = value;
 
  // Update the qp values as well
  auto & u = _vector_tag_u[_solution_tag];
  for (unsigned int qp = 0; qp < u.size(); qp++)
    u[qp] = value;
}
 
template <>
void
MooseVariableDataBase<RealVectorValue>::setNodalValue(const RealVectorValue & value)
{
  // Unlike the generic implementation above, a vector-valued variable is never an array
  // variable, so _count is always 1 and dof_values is indexed per component of the vector
  // rather than per shape function -- each shape function contributes one raw degree of
  // freedom per component given the finite element family and order constraints we set below.
  mooseAssert(_count == 1, "Vector-valued variables cannot be array variables");
  mooseAssert(
      _var.feType().family == LAGRANGE_VEC ||
          (_var.feType().family == MONOMIAL_VEC && _var.feType().order == CONSTANT &&
           (!_var.feType().p_refinement || !_subproblem.doingPRefinement())),
      "setNodalValue only makes sense for LAGRANGE_VEC or non-p-refined CONSTANT MONOMIAL_VEC "
      "vector variables");
  mooseAssert(_dof_indices.size() <= _var.sys().mesh().getMesh().mesh_dimension(),
              "The number of dof indices for a vector variable should be at most the mesh manifold "
              "dimension. We cannot use an exact equality because it's possible the vector "
              "variable could live on a lower-dimensional manifold.");
 
  auto & dof_values = _vector_tags_dof_u[_solution_tag];
  dof_values.resize(_dof_indices.size());
  for (const auto i : index_range(dof_values))
    dof_values[i] = value(i);
 
  _has_dof_values = true;
  _nodal_value = value;
}
 
template <typename OutputType>
void
MooseVariableDataBase<OutputType>::insert(NumericVector<Number> & residual)
{
  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);
  }
}
 
template <>
void
MooseVariableDataBase<RealEigenVector>::insert(NumericVector<Number> & residual)
{
  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));
    }
  }
}
 
template <typename OutputType>
void
MooseVariableDataBase<OutputType>::add(NumericVector<Number> & residual)
{
  if (_has_dof_values)
  {
    const auto & dof_values = _vector_tags_dof_u[_solution_tag];
    residual.add_vector(&dof_values[0], _dof_indices);
  }
}
 
template <>
void
MooseVariableDataBase<RealEigenVector>::add(NumericVector<Number> & residual)
{
  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));
    }
  }
}
 
template <typename OutputType>
const OutputType &
MooseVariableDataBase<OutputType>::nodalValue(Moose::SolutionState state) const
{
  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.");
}
 
template <typename OutputType>
const MooseArray<OutputType> &
MooseVariableDataBase<OutputType>::nodalValueArray(Moose::SolutionState state) const
{
  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.");
}
 
template <typename OutputType>
void
MooseVariableDataBase<OutputType>::fetchDofValues()
{
  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]);
        }
    }
  }
}
 
template <typename OutputType>
void
MooseVariableDataBase<OutputType>::getArrayDofValues(const NumericVector<Number> & sol,
                                                     const unsigned int nshapes,
                                                     MooseArray<RealEigenVector> & dof_values) const
{
  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]);
  }
}
 
template <>
void
MooseVariableDataBase<RealEigenVector>::fetchDofValues()
{
  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();
  }
}
 
template <typename OutputType>
void
MooseVariableDataBase<OutputType>::zeroSizeDofValues()
{
  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;
}
 
template <typename OutputType>
void
MooseVariableDataBase<OutputType>::assignNodalValue()
{
  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];
}
 
template <>
void
MooseVariableDataBase<RealVectorValue>::assignNodalValue()
{
  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];
  }
}
 
template class MooseVariableDataBase<Real>;
template class MooseVariableDataBase<RealVectorValue>;
template class MooseVariableDataBase<RealEigenVector>;