MooseVariableFE.h

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
 
#pragma once
 
#include "MooseTypes.h"
#include "MooseVariableFEBase.h"
#include "SubProblem.h"
#include "MooseMesh.h"
#include "MooseVariableField.h"
#include "MooseVariableData.h"
 
#include "libmesh/numeric_vector.h"
#include "libmesh/dof_map.h"
#include "libmesh/elem.h"
#include "libmesh/quadrature.h"
#include "libmesh/dense_vector.h"
#include "libmesh/enum_fe_family.h"
 
class TimeIntegrator;
template <typename>
class MooseVariableFE;
typedef MooseVariableFE<Real> MooseVariable;
typedef MooseVariableFE<RealVectorValue> VectorMooseVariable;
typedef MooseVariableFE<RealEigenVector> ArrayMooseVariable;
 
template <typename OutputType>
class MooseVariableFE : public MooseVariableField<OutputType>
{
public:
  using OutputGradient = typename MooseVariableField<OutputType>::OutputGradient;
  using OutputSecond = typename MooseVariableField<OutputType>::OutputSecond;
  using OutputDivergence = typename MooseVariableField<OutputType>::OutputDivergence;
 
  using FieldVariableValue = typename MooseVariableField<OutputType>::FieldVariableValue;
  using FieldVariableGradient = typename MooseVariableField<OutputType>::FieldVariableGradient;
  using FieldVariableSecond = typename MooseVariableField<OutputType>::FieldVariableSecond;
  using FieldVariableCurl = typename MooseVariableField<OutputType>::FieldVariableCurl;
  using FieldVariableDivergence = typename MooseVariableField<OutputType>::FieldVariableDivergence;
 
  using OutputShape = typename MooseVariableField<OutputType>::OutputShape;
  using OutputShapeGradient = typename MooseVariableField<OutputType>::OutputShapeGradient;
  using OutputShapeSecond = typename MooseVariableField<OutputType>::OutputShapeSecond;
  using OutputShapeDivergence = typename MooseVariableField<OutputType>::OutputShapeDivergence;
 
  using FieldVariablePhiValue = typename MooseVariableField<OutputType>::FieldVariablePhiValue;
  using FieldVariablePhiGradient =
      typename MooseVariableField<OutputType>::FieldVariablePhiGradient;
  using FieldVariablePhiSecond = typename MooseVariableField<OutputType>::FieldVariablePhiSecond;
  using FieldVariablePhiCurl = typename MooseVariableField<OutputType>::FieldVariablePhiCurl;
  using FieldVariablePhiDivergence =
      typename MooseVariableField<OutputType>::FieldVariablePhiDivergence;
 
  using FieldVariableTestValue = typename MooseVariableField<OutputType>::FieldVariableTestValue;
  using FieldVariableTestGradient =
      typename MooseVariableField<OutputType>::FieldVariableTestGradient;
  using FieldVariableTestSecond = typename MooseVariableField<OutputType>::FieldVariableTestSecond;
  using FieldVariableTestCurl = typename MooseVariableField<OutputType>::FieldVariableTestCurl;
  using FieldVariableTestDivergence =
      typename MooseVariableField<OutputType>::FieldVariableTestDivergence;
 
  using typename MooseVariableField<OutputType>::DofValue;
  using typename MooseVariableField<OutputType>::DofValues;
  using typename MooseVariableField<OutputType>::ADDofValue;
  using typename MooseVariableField<OutputType>::ADDofValues;
 
  using FunctorArg = typename Moose::ADType<OutputType>::type;
  using typename Moose::FunctorBase<FunctorArg>::ValueType;
  using typename Moose::FunctorBase<FunctorArg>::GradientType;
  using typename Moose::FunctorBase<FunctorArg>::DotType;
 
  MooseVariableFE(const InputParameters & parameters);
 
  static InputParameters validParams();
 
  void clearDofIndices() override;
 
  void prepare() override;
  void prepareNeighbor() override;
  void prepareLowerD() override;
  virtual void prepareIC() override;
 
  void prepareAux() override;
 
  void reinitNode() override;
  void reinitAux() override;
  void reinitAuxNeighbor() override;
 
  void reinitNodes(const std::vector<dof_id_type> & nodes) override;
  void reinitNodesNeighbor(const std::vector<dof_id_type> & nodes) override;
 
  bool usesPhi() const { return true; }
  bool usesGradPhi() const { return true; }
 
  bool usesSecondPhi() const;
 
  bool usesSecondPhiNeighbor() const override final;
 
  bool computingSecond() const override final { return usesSecondPhi(); }
 
  bool computingCurl() const override final;
 
  bool computingDiv() const override final;
 
  bool isNodal() const override { return _element_data->isNodal(); }
  bool hasDoFsOnNodes() const override { return _element_data->hasDoFsOnNodes(); }
  bool supportsQpBasedLoops() const override { return true; }
  bool supportsGeometricInfoBasedLoops() const override { return false; }
  libMesh::FEContinuity getContinuity() const override { return _element_data->getContinuity(); };
  const Node * const & node() const { return _element_data->node(); }
  const dof_id_type & nodalDofIndex() const override { return _element_data->nodalDofIndex(); }
  virtual bool isNodalDefined() const override;
 
  const Node * const & nodeNeighbor() const { return _neighbor_data->node(); }
  const dof_id_type & nodalDofIndexNeighbor() const override
  {
    return _neighbor_data->nodalDofIndex();
  }
  bool isNodalNeighborDefined() const;
 
  const Elem * const & currentElem() const override { return _element_data->currentElem(); }
 
  const unsigned int & currentSide() const { return _element_data->currentSide(); }
 
  const Elem * const & neighbor() const { return _neighbor_data->currentElem(); }
 
  virtual void getDofIndices(const Elem * elem,
                             std::vector<dof_id_type> & dof_indices) const override;
  const std::vector<dof_id_type> & dofIndices() const final { return _element_data->dofIndices(); }
  unsigned int numberOfDofs() const final { return _element_data->numberOfDofs(); }
  const std::vector<dof_id_type> & dofIndicesNeighbor() const final
  {
    return _neighbor_data->dofIndices();
  }
  const std::vector<dof_id_type> & dofIndicesLower() const final
  {
    return _lower_data->dofIndices();
  }
 
  void clearAllDofIndices() final;
 
  unsigned int numberOfDofsNeighbor() override { return _neighbor_data->dofIndices().size(); }
 
  const FieldVariablePhiValue & phi() const override { return _element_data->phi(); }
  const FieldVariablePhiGradient & gradPhi() const override final
  {
    return _element_data->gradPhi();
  }
  const MappedArrayVariablePhiGradient & arrayGradPhi() const
  {
    return _element_data->arrayGradPhi();
  }
  const FieldVariablePhiSecond & secondPhi() const override final;
  const FieldVariablePhiCurl & curlPhi() const override final;
  const FieldVariablePhiDivergence & divPhi() const override final;
 
  const FieldVariablePhiValue & phiFace() const override final { return _element_data->phiFace(); }
  const FieldVariablePhiGradient & gradPhiFace() const override final
  {
    return _element_data->gradPhiFace();
  }
  const MappedArrayVariablePhiGradient & arrayGradPhiFace() const
  {
    return _element_data->arrayGradPhiFace();
  }
  const FieldVariablePhiSecond & secondPhiFace() const override final;
  const FieldVariablePhiCurl & curlPhiFace() const;
  const FieldVariablePhiDivergence & divPhiFace() const;
 
  const FieldVariablePhiValue & phiNeighbor() const override final { return _neighbor_data->phi(); }
  const FieldVariablePhiGradient & gradPhiNeighbor() const override final
  {
    return _neighbor_data->gradPhi();
  }
  const MappedArrayVariablePhiGradient & arrayGradPhiNeighbor() const
  {
    return _neighbor_data->arrayGradPhi();
  }
  const FieldVariablePhiSecond & secondPhiNeighbor() const override final;
  const FieldVariablePhiCurl & curlPhiNeighbor() const;
  const FieldVariablePhiDivergence & divPhiNeighbor() const;
 
  const FieldVariablePhiValue & phiFaceNeighbor() const override final
  {
    return _neighbor_data->phiFace();
  }
  const FieldVariablePhiGradient & gradPhiFaceNeighbor() const override final
  {
    return _neighbor_data->gradPhiFace();
  }
  const MappedArrayVariablePhiGradient & arrayGradPhiFaceNeighbor() const
  {
    return _neighbor_data->arrayGradPhiFace();
  }
  const FieldVariablePhiSecond & secondPhiFaceNeighbor() const override final;
  const FieldVariablePhiCurl & curlPhiFaceNeighbor() const;
  const FieldVariablePhiDivergence & divPhiFaceNeighbor() const;
 
  virtual const FieldVariablePhiValue & phiLower() const override { return _lower_data->phi(); }
  const FieldVariablePhiGradient & gradPhiLower() const { return _lower_data->gradPhi(); }
 
  const ADTemplateVariableTestGradient<OutputShape> & adGradPhi() const
  {
    return _element_data->adGradPhi();
  }
 
  const ADTemplateVariableTestGradient<OutputShape> & adGradPhiFace() const
  {
    return _element_data->adGradPhiFace();
  }
 
  const ADTemplateVariableTestGradient<OutputShape> & adGradPhiFaceNeighbor() const
  {
    return _neighbor_data->adGradPhiFace();
  }
 
  // damping
  const FieldVariableValue & increment() const { return _element_data->increment(); }
 
  const FieldVariableValue & vectorTagValue(TagID tag) const override
  {
    return _element_data->vectorTagValue(tag);
  }
  const FieldVariableGradient & vectorTagGradient(TagID tag) const
  {
    return _element_data->vectorTagGradient(tag);
  }
  const DofValues & vectorTagDofValue(TagID tag) const override
  {
    return _element_data->vectorTagDofValue(tag);
  }
  const FieldVariableValue & matrixTagValue(TagID tag) const override
  {
    return _element_data->matrixTagValue(tag);
  }
 
  const FieldVariableValue & sln() const override { return _element_data->sln(Moose::Current); }
  const FieldVariableValue & slnOld() const override { return _element_data->sln(Moose::Old); }
  const FieldVariableValue & slnOlder() const override { return _element_data->sln(Moose::Older); }
  const FieldVariableValue & slnPreviousNL() const { return _element_data->sln(Moose::PreviousNL); }
 
  const FieldVariableGradient & gradSln() const override
  {
    return _element_data->gradSln(Moose::Current);
  }
  const FieldVariableGradient & gradSlnOld() const override
  {
    return _element_data->gradSln(Moose::Old);
  }
  const FieldVariableGradient & gradSlnOlder() const
  {
    return _element_data->gradSln(Moose::Older);
  }
  const FieldVariableGradient & gradSlnPreviousNL() const
  {
    return _element_data->gradSln(Moose::PreviousNL);
  }
 
  const FieldVariableGradient & gradSlnDot() const { return _element_data->gradSlnDot(); }
  const FieldVariableGradient & gradSlnDotDot() const { return _element_data->gradSlnDotDot(); }
 
  const FieldVariableSecond & secondSln() const { return _element_data->secondSln(Moose::Current); }
  const FieldVariableSecond & secondSlnOld() const { return _element_data->secondSln(Moose::Old); }
  const FieldVariableSecond & secondSlnOlder() const
  {
    return _element_data->secondSln(Moose::Older);
  }
  const FieldVariableSecond & secondSlnPreviousNL() const
  {
    return _element_data->secondSln(Moose::PreviousNL);
  }
 
  const FieldVariableCurl & curlSln() const { return _element_data->curlSln(Moose::Current); }
  const FieldVariableCurl & curlSlnOld() const { return _element_data->curlSln(Moose::Old); }
  const FieldVariableCurl & curlSlnOlder() const { return _element_data->curlSln(Moose::Older); }
 
  const FieldVariableDivergence & divSln() const { return _element_data->divSln(Moose::Current); }
  const FieldVariableDivergence & divSlnOld() const { return _element_data->divSln(Moose::Old); }
  const FieldVariableDivergence & divSlnOlder() const
  {
    return _element_data->divSln(Moose::Older);
  }
 
  const ADTemplateVariableValue<OutputType> & adSln() const override
  {
    return _element_data->adSln();
  }
 
  const ADTemplateVariableGradient<OutputType> & adGradSln() const override
  {
    return _element_data->adGradSln();
  }
 
  const ADTemplateVariableValue<OutputType> & adSlnFace() const
  {
    return _element_data->adSlnFace();
  }
  const ADTemplateVariableGradient<OutputType> & adGradSlnFace() const override
  {
    return _element_data->adGradSlnFace();
  }
  const ADTemplateVariableSecond<OutputType> & adSecondSln() const override
  {
    return _element_data->adSecondSln();
  }
  const ADTemplateVariableValue<OutputType> & adUDot() const override
  {
    return _element_data->adUDot();
  }
  const ADTemplateVariableValue<OutputType> & adUDotDot() const override
  {
    return _element_data->adUDotDot();
  }
  const ADTemplateVariableGradient<OutputType> & adGradSlnDot() const override
  {
    return _element_data->adGradSlnDot();
  }
  const ADTemplateVariableCurl<OutputType> & adCurlSln() const override
  {
    return _element_data->adCurlSln();
  }
 
  const ADTemplateVariableValue<OutputType> & adSlnNeighbor() const override
  {
    return _neighbor_data->adSln();
  }
  const ADTemplateVariableGradient<OutputType> & adGradSlnNeighbor() const override
  {
    return _neighbor_data->adGradSln();
  }
  const ADTemplateVariableSecond<OutputType> & adSecondSlnNeighbor() const override
  {
    return _neighbor_data->adSecondSln();
  }
  const ADTemplateVariableValue<OutputType> & adUDotNeighbor() const override
  {
    return _neighbor_data->adUDot();
  }
  const ADTemplateVariableValue<OutputType> & adUDotDotNeighbor() const override
  {
    return _neighbor_data->adUDotDot();
  }
  const ADTemplateVariableGradient<OutputType> & adGradSlnNeighborDot() const override
  {
    return _neighbor_data->adGradSlnDot();
  }
  const ADTemplateVariableCurl<OutputType> & adCurlSlnNeighbor() const override
  {
    return _neighbor_data->adCurlSln();
  }
 
  const FieldVariableValue & uDot() const { return _element_data->uDot(); }
  const FieldVariableValue & uDotDot() const { return _element_data->uDotDot(); }
  const FieldVariableValue & uDotOld() const { return _element_data->uDotOld(); }
  const FieldVariableValue & uDotDotOld() const { return _element_data->uDotDotOld(); }
  const VariableValue & duDotDu() const { return _element_data->duDotDu(); }
  const VariableValue & duDotDotDu() const { return _element_data->duDotDotDu(); }
 
  const FieldVariableValue & slnNeighbor() const override
  {
    return _neighbor_data->sln(Moose::Current);
  }
  const FieldVariableValue & slnOldNeighbor() const override
  {
    return _neighbor_data->sln(Moose::Old);
  }
  const FieldVariableValue & slnOlderNeighbor() const { return _neighbor_data->sln(Moose::Older); }
  const FieldVariableValue & slnPreviousNLNeighbor() const
  {
    return _neighbor_data->sln(Moose::PreviousNL);
  }
 
  const FieldVariableGradient & gradSlnNeighbor() const override
  {
    return _neighbor_data->gradSln(Moose::Current);
  }
  const FieldVariableGradient & gradSlnOldNeighbor() const override
  {
    return _neighbor_data->gradSln(Moose::Old);
  }
  const FieldVariableGradient & gradSlnOlderNeighbor() const
  {
    return _neighbor_data->gradSln(Moose::Older);
  }
  const FieldVariableGradient & gradSlnPreviousNLNeighbor() const
  {
    return _neighbor_data->gradSln(Moose::PreviousNL);
  }
 
  const FieldVariableGradient & gradSlnNeighborDot() const { return _neighbor_data->gradSlnDot(); }
  const FieldVariableGradient & gradSlnNeighborDotDot() const
  {
    return _neighbor_data->gradSlnDotDot();
  }
 
  const FieldVariableSecond & secondSlnNeighbor() const
  {
    return _neighbor_data->secondSln(Moose::Current);
  }
  const FieldVariableSecond & secondSlnOldNeighbor() const
  {
    return _neighbor_data->secondSln(Moose::Old);
  }
  const FieldVariableSecond & secondSlnOlderNeighbor() const
  {
    return _neighbor_data->secondSln(Moose::Older);
  }
  const FieldVariableSecond & secondSlnPreviousNLNeighbor() const
  {
    return _neighbor_data->secondSln(Moose::PreviousNL);
  }
 
  const FieldVariableCurl & curlSlnNeighbor() const
  {
    return _neighbor_data->curlSln(Moose::Current);
  }
  const FieldVariableCurl & curlSlnOldNeighbor() const
  {
    return _neighbor_data->curlSln(Moose::Old);
  }
  const FieldVariableCurl & curlSlnOlderNeighbor() const
  {
    return _neighbor_data->curlSln(Moose::Older);
  }
 
  const FieldVariableDivergence & divSlnNeighbor() const
  {
    return _neighbor_data->divSln(Moose::Current);
  }
  const FieldVariableDivergence & divSlnOldNeighbor() const
  {
    return _neighbor_data->divSln(Moose::Old);
  }
  const FieldVariableDivergence & divSlnOlderNeighbor() const
  {
    return _neighbor_data->divSln(Moose::Older);
  }
 
  const FieldVariableValue & uDotNeighbor() const { return _neighbor_data->uDot(); }
  const FieldVariableValue & uDotDotNeighbor() const { return _neighbor_data->uDotDot(); }
  const FieldVariableValue & uDotOldNeighbor() const { return _neighbor_data->uDotOld(); }
  const FieldVariableValue & uDotDotOldNeighbor() const { return _neighbor_data->uDotDotOld(); }
  const VariableValue & duDotDuNeighbor() const { return _neighbor_data->duDotDu(); }
  const VariableValue & duDotDotDuNeighbor() const { return _neighbor_data->duDotDotDu(); }
 
  const ADTemplateVariableValue<OutputType> & adSlnLower() const { return _lower_data->adSln(); }
  const FieldVariableValue & slnLower() const { return _lower_data->sln(Moose::Current); }
  const FieldVariableValue & slnLowerOld() const { return _lower_data->sln(Moose::Old); }
 
  virtual void computeElemValues() override;
  virtual void computeElemValuesFace() override;
  virtual void computeNeighborValuesFace() override;
  virtual void computeNeighborValues() override;
  virtual void computeLowerDValues() override;
 
  virtual void setNodalValue(const OutputType & value) override;
 
  virtual void setDofValue(const DofValue & value, unsigned int index) override;
 
  virtual void setDofValues(const DenseVector<DofValue> & values) override;
  virtual void setLowerDofValues(const DenseVector<DofValue> & values) override;
 
  void insertNodalValue(libMesh::NumericVector<libMesh::Number> & residual, const DofValue & v);
 
  DofValue getNodalValue(const Node & node) const;
  DofValue getNodalValueOld(const Node & node) const;
  DofValue getNodalValueOlder(const Node & node) const;
  DofValue getElementalValue(const Elem * elem, unsigned int idx = 0) const;
  DofValue getElementalValueOld(const Elem * elem, unsigned int idx = 0) const;
  DofValue getElementalValueOlder(const Elem * elem, unsigned int idx = 0) const;
 
  virtual void insert(libMesh::NumericVector<libMesh::Number> & vector) override;
  virtual void insertLower(libMesh::NumericVector<libMesh::Number> & vector) override;
 
  virtual void add(libMesh::NumericVector<libMesh::Number> & vector) override;
 
  void addSolution(const DenseVector<libMesh::Number> & v);
 
  void addSolutionNeighbor(const DenseVector<libMesh::Number> & v);
 
  const DofValues & dofValue() const;
  const DofValues & dofValues() const override;
  const DofValues & dofValuesOld() const override;
  const DofValues & dofValuesOlder() const override;
  const DofValues & dofValuesPreviousNL() const override;
  const DofValues & dofValuesNeighbor() const override;
  const DofValues & dofValuesOldNeighbor() const override;
  const DofValues & dofValuesOlderNeighbor() const override;
  const DofValues & dofValuesPreviousNLNeighbor() const override;
  const DofValues & dofValuesDot() const override;
  const DofValues & dofValuesDotNeighbor() const override;
  const DofValues & dofValuesDotNeighborResidual() const;
  const DofValues & dofValuesDotOld() const override;
  const DofValues & dofValuesDotOldNeighbor() const override;
  const DofValues & dofValuesDotDot() const override;
  const DofValues & dofValuesDotDotNeighbor() const override;
  const DofValues & dofValuesDotDotNeighborResidual() const;
  const DofValues & dofValuesDotDotOld() const override;
  const DofValues & dofValuesDotDotOldNeighbor() const override;
  const MooseArray<libMesh::Number> & dofValuesDuDotDu() const override;
  const MooseArray<libMesh::Number> & dofValuesDuDotDuNeighbor() const override;
  const MooseArray<libMesh::Number> & dofValuesDuDotDotDu() const override;
  const MooseArray<libMesh::Number> & dofValuesDuDotDotDuNeighbor() const override;
 
  const ADDofValues & adDofValues() const override;
  const ADDofValues & adDofValuesNeighbor() const override;
  const ADDofValues & adDofValuesDot() const override;
 
  void computeIncrementAtQps(const libMesh::NumericVector<libMesh::Number> & increment_vec);
 
  void computeIncrementAtNode(const libMesh::NumericVector<libMesh::Number> & increment_vec);
 
  OutputType getValue(const Elem * elem, const std::vector<std::vector<OutputShape>> & phi) const;
 
  typename OutputTools<OutputType>::OutputGradient getGradient(
      const Elem * elem,
      const std::vector<std::vector<typename OutputTools<OutputType>::OutputShapeGradient>> &
          grad_phi) const;
 
  virtual std::size_t phiSize() const final { return _element_data->phiSize(); }
  virtual std::size_t phiFaceSize() const final { return _element_data->phiFaceSize(); }
  virtual std::size_t phiNeighborSize() const final { return _neighbor_data->phiSize(); }
  virtual std::size_t phiFaceNeighborSize() const final { return _neighbor_data->phiFaceSize(); }
 
  std::size_t phiLowerSize() const final { return _lower_data->phiSize(); }
 
  const OutputType & nodalValue() const;
  const OutputType & nodalValueOld() const;
  const OutputType & nodalValueOlder() const;
  const OutputType & nodalValuePreviousNL() const;
  const OutputType & nodalValueDot() const;
  const OutputType & nodalValueDotDot() const;
  const OutputType & nodalValueDotOld() const;
  const OutputType & nodalValueDotDotOld() const;
  const OutputType & nodalValueDuDotDu() const;
  const OutputType & nodalValueDuDotDotDu() const;
  const OutputType & nodalValueNeighbor() const;
  const OutputType & nodalValueOldNeighbor() const;
  const OutputType & nodalValueOlderNeighbor() const;
  const OutputType & nodalValuePreviousNLNeighbor() const;
  const OutputType & nodalValueDotNeighbor() const;
  const OutputType & nodalValueDotNeighborResidual() const;
  const OutputType & nodalValueDotDotNeighbor() const;
  const OutputType & nodalValueDotDotNeighborResidual() const;
  const OutputType & nodalValueDotOldNeighbor() const;
  const OutputType & nodalValueDotDotOldNeighbor() const;
  const OutputType & nodalValueDuDotDuNeighbor() const;
  const OutputType & nodalValueDuDotDotDuNeighbor() const;
 
  const MooseArray<OutputType> & nodalValueArray() const override
  {
    return _element_data->nodalValueArray(Moose::Current);
  }
  const MooseArray<OutputType> & nodalValueOldArray() const override
  {
    return _element_data->nodalValueArray(Moose::Old);
  }
  const MooseArray<OutputType> & nodalValueOlderArray() const override
  {
    return _element_data->nodalValueArray(Moose::Older);
  }
 
  const DofValues & nodalVectorTagValue(TagID tag) const override;
  const DofValues & nodalMatrixTagValue(TagID tag) const override;
 
  const typename Moose::ADType<OutputType>::type & adNodalValue() const;
 
  virtual void computeNodalValues() override;
  virtual void computeNodalNeighborValues() override;
 
  unsigned int oldestSolutionStateRequested() const override final;
 
  void setActiveTags(const std::set<TagID> & vtags) override;
 
  virtual void meshChanged() override;
  virtual void residualSetup() override;
  virtual void jacobianSetup() override;
 
  virtual void sizeMatrixTagData() override;
 
  bool supportsFaceArg() const override final { return true; }
  bool supportsElemSideQpArg() const override final { return true; }
 
protected:
  usingMooseVariableFieldMembers;
 
  std::unique_ptr<MooseVariableData<OutputType>> _element_data;
 
  std::unique_ptr<MooseVariableData<OutputType>> _neighbor_data;
 
  std::unique_ptr<MooseVariableData<OutputType>> _lower_data;
 
  using MooseVariableField<OutputType>::evaluate;
  using MooseVariableField<OutputType>::evaluateGradient;
  using MooseVariableField<OutputType>::evaluateDot;
  using MooseVariableField<OutputType>::evaluateGradDot;
  using ElemArg = Moose::ElemArg;
  using ElemQpArg = Moose::ElemQpArg;
  using ElemSideQpArg = Moose::ElemSideQpArg;
  using FaceArg = Moose::FaceArg;
  using StateArg = Moose::StateArg;
  using NodeArg = Moose::NodeArg;
  using ElemPointArg = Moose::ElemPointArg;
 
  ValueType
  faceEvaluate(const FaceArg &, const StateArg &, const std::vector<ValueType> & cache_data) const;
 
  ValueType evaluate(const ElemQpArg & elem_qp, const StateArg & state) const override final;
  ValueType evaluate(const ElemSideQpArg & elem_side_qp,
                     const StateArg & state) const override final;
  ValueType evaluate(const ElemArg &, const StateArg &) const override final;
  ValueType evaluate(const ElemPointArg &, const StateArg &) const override final;
  ValueType evaluate(const NodeArg & node_arg, const StateArg & state) const override final;
  ValueType evaluate(const FaceArg &, const StateArg &) const override final;
 
  GradientType evaluateGradient(const ElemQpArg & elem_qp, const StateArg & state) const override;
  GradientType evaluateGradient(const ElemSideQpArg & elem_side_qp,
                                const StateArg & state) const override final;
  GradientType evaluateGradient(const ElemArg &, const StateArg &) const override final;
 
  DotType evaluateDot(const ElemQpArg & elem_qp, const StateArg & state) const override final;
  DotType evaluateDot(const ElemSideQpArg & elem_side_qp,
                      const StateArg & state) const override final;
  DotType evaluateDot(const ElemArg &, const StateArg &) const override final;
  DotType evaluateDot(const FaceArg &, const StateArg &) const override final;
 
  GradientType evaluateGradDot(const ElemArg &, const StateArg &) const override final;
 
private:
  template <typename Shapes, typename Solution, typename GradShapes, typename GradSolution>
  void computeSolution(const Elem * elem,
                       unsigned int n_qp,
                       const StateArg & state,
                       const Shapes & phi,
                       Solution & local_soln,
                       const GradShapes & grad_phi,
                       GradSolution & grad_local_soln,
                       Solution & dot_local_soln,
                       GradSolution & grad_dot_local_soln) const;
 
  void
  evaluateOnElement(const ElemQpArg & elem_qp, const StateArg & state, bool cache_eligible) const;
 
  void evaluateOnElementSide(const ElemSideQpArg & elem_side_qp,
                             const StateArg & state,
                             bool cache_eligible) const;
 
  mutable const Elem * _current_elem_qp_functor_elem = nullptr;
 
  mutable std::vector<ValueType> _current_elem_qp_functor_sln;
 
  mutable std::vector<GradientType> _current_elem_qp_functor_gradient;
 
  mutable std::vector<DotType> _current_elem_qp_functor_dot;
 
  mutable std::vector<GradientType> _current_elem_qp_functor_grad_dot;
 
  mutable std::pair<const Elem *, unsigned int> _current_elem_side_qp_functor_elem_side{
      nullptr, libMesh::invalid_uint};
 
  mutable std::vector<ValueType> _current_elem_side_qp_functor_sln;
 
  mutable std::vector<GradientType> _current_elem_side_qp_functor_gradient;
 
  mutable std::vector<DotType> _current_elem_side_qp_functor_dot;
 
  mutable std::vector<GradientType> _current_elem_side_qp_functor_grad_dot;
};
 
template <typename OutputType>
inline const typename MooseVariableFE<OutputType>::ADDofValues &
MooseVariableFE<OutputType>::adDofValues() const
{
  return _element_data->adDofValues();
}
 
template <typename OutputType>
inline const typename MooseVariableFE<OutputType>::ADDofValues &
MooseVariableFE<OutputType>::adDofValuesNeighbor() const
{
  return _neighbor_data->adDofValues();
}
 
template <typename OutputType>
inline const typename MooseVariableFE<OutputType>::ADDofValues &
MooseVariableFE<OutputType>::adDofValuesDot() const
{
  return _element_data->adDofValuesDot();
}
 
template <typename OutputType>
inline const typename Moose::ADType<OutputType>::type &
MooseVariableFE<OutputType>::adNodalValue() const
{
  return _element_data->adNodalValue();
}
 
template <typename OutputType>
void
MooseVariableFE<OutputType>::setActiveTags(const std::set<TagID> & vtags)
{
  _element_data->setActiveTags(vtags);
  _neighbor_data->setActiveTags(vtags);
  _lower_data->setActiveTags(vtags);
}
 
// Declare all the specializations, as the template specialization declarations below must know
template <>
InputParameters MooseVariableFE<Real>::validParams();
template <>
InputParameters MooseVariableFE<RealVectorValue>::validParams();
template <>
InputParameters MooseVariableFE<RealEigenVector>::validParams();
template <>
RealEigenVector
MooseVariableFE<RealEigenVector>::getValue(const Elem * elem,
                                           const std::vector<std::vector<Real>> & phi) const;
template <>
RealVectorArrayValue MooseVariableFE<RealEigenVector>::getGradient(
    const Elem * elem, const std::vector<std::vector<RealVectorValue>> & grad_phi) const;
template <>
void MooseVariableFE<RealEigenVector>::evaluateOnElement(const ElemQpArg &,
                                                         const StateArg &,
                                                         bool) const;
template <>
void MooseVariableFE<RealEigenVector>::evaluateOnElementSide(const ElemSideQpArg &,
                                                             const StateArg &,
                                                             bool) const;
template <>
typename MooseVariableFE<RealEigenVector>::ValueType
MooseVariableFE<RealEigenVector>::evaluate(const ElemQpArg &, const StateArg &) const;
template <>
typename MooseVariableFE<RealEigenVector>::ValueType
MooseVariableFE<RealEigenVector>::evaluate(const ElemSideQpArg &, const StateArg &) const;
template <>
typename MooseVariableFE<RealEigenVector>::GradientType
MooseVariableFE<RealEigenVector>::evaluateGradient(const ElemQpArg &, const StateArg &) const;
template <>
typename MooseVariableFE<RealEigenVector>::GradientType
MooseVariableFE<RealEigenVector>::evaluateGradient(const ElemSideQpArg &, const StateArg &) const;
template <>
typename MooseVariableFE<RealEigenVector>::DotType
MooseVariableFE<RealEigenVector>::evaluateDot(const ElemQpArg &, const StateArg &) const;
template <>
typename MooseVariableFE<RealEigenVector>::DotType
MooseVariableFE<RealEigenVector>::evaluateDot(const ElemSideQpArg &, const StateArg &) const;
 
// Prevent implicit instantiation in other translation units where these classes are used
extern template class MooseVariableFE<Real>;
extern template class MooseVariableFE<RealVectorValue>;
extern template class MooseVariableFE<RealEigenVector>;