MooseVariableFV.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 "MooseVariableField.h"
#include "SubProblem.h"
#include "MooseMesh.h"
#include "MooseVariableDataFV.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"

template <typename>
class MooseVariableFV;

typedef MooseVariableFV<Real> MooseVariableFVReal;
class FVDirichletBCBase;
class FVFluxBC;

namespace libMesh
{
template <typename>
class NumericVector;
}

template <typename OutputType>
class MooseVariableFV : 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 OutputData = typename MooseVariableField<OutputType>::OutputData;
  using DoFValue = typename MooseVariableField<OutputType>::DoFValue;

  using FieldVariablePhiValue = typename MooseVariableField<OutputType>::FieldVariablePhiValue;
  using FieldVariablePhiDivergence =
      typename MooseVariableField<OutputType>::FieldVariablePhiDivergence;
  using FieldVariablePhiGradient =
      typename MooseVariableField<OutputType>::FieldVariablePhiGradient;
  using FieldVariablePhiSecond = typename MooseVariableField<OutputType>::FieldVariablePhiSecond;
  using ElemQpArg = Moose::ElemQpArg;
  using ElemSideQpArg = Moose::ElemSideQpArg;
  using ElemArg = Moose::ElemArg;
  using FaceArg = Moose::FaceArg;
  using StateArg = Moose::StateArg;
  using NodeArg = Moose::NodeArg;
  using ElemPointArg = Moose::ElemPointArg;
  using typename MooseVariableField<OutputType>::ValueType;
  using typename MooseVariableField<OutputType>::DotType;
  using typename MooseVariableField<OutputType>::GradientType;

  static InputParameters validParams();

  MooseVariableFV(const InputParameters & parameters);

  virtual bool isFV() const override { return true; }

  // TODO: many of these functions are not relevant to FV variables but are
  // still called at various points from existing moose code paths.  Ideally we
  // would figure out how to remove calls to these functions and then allow
  // throwing mooseError's from them instead of silently doing nothing (e.g.
  // reinitNodes, reinitAux, prepareLowerD, etc.).

  virtual void prepare() override final {}
  virtual void prepareNeighbor() override final {}
  virtual void prepareAux() override final;
  virtual void reinitNode() override final {}
  virtual void reinitNodes(const std::vector<dof_id_type> & /*nodes*/) override final {}
  virtual void reinitNodesNeighbor(const std::vector<dof_id_type> & /*nodes*/) override final {}
  virtual void reinitAux() override final {}
  virtual void reinitAuxNeighbor() override final {}
  virtual void prepareLowerD() override final {}

  virtual const dof_id_type & nodalDofIndex() const override final
  {
    mooseError("nodalDofIndex not supported by MooseVariableFVBase");
  }
  virtual const dof_id_type & nodalDofIndexNeighbor() const override final
  {
    mooseError("nodalDofIndexNeighbor not supported by MooseVariableFVBase");
  }
  virtual std::size_t phiSize() const override final { return _phi.size(); }
  virtual std::size_t phiFaceSize() const override final { return _phi_face.size(); }
  virtual std::size_t phiNeighborSize() const override final { return _phi_neighbor.size(); }
  virtual std::size_t phiFaceNeighborSize() const override final
  {
    return _phi_face_neighbor.size();
  }
  virtual std::size_t phiLowerSize() const override final
  {
    mooseError("phiLowerSize not supported by MooseVariableFVBase");
  }

  virtual void computeElemValuesFace() override;
  virtual void computeNeighborValuesFace() override;
  virtual void computeNeighborValues() override;
  virtual void computeLowerDValues() override final
  {
    // mooseError("computeLowerDValues not supported by MooseVariableFVBase");
  }
  virtual void computeNodalNeighborValues() override final
  {
    // mooseError("computeNodalNeighborValues not supported by MooseVariableFVBase");
  }
  virtual void computeNodalValues() override final
  {
    // mooseError("computeNodalValues not supported by MooseVariableFVBase");
  }
  virtual const std::vector<dof_id_type> & dofIndicesLower() const override final;

  unsigned int numberOfDofs() const override final { return _element_data->numberOfDofs(); }

  virtual unsigned int numberOfDofsNeighbor() override final
  {
    mooseError("numberOfDofsNeighbor not supported by MooseVariableFVBase");
  }

  virtual bool isNodal() const override final { return false; }

  bool hasDoFsOnNodes() const override final { return false; }

  libMesh::FEContinuity getContinuity() const override final
  {
    return _element_data->getContinuity();
  };

  virtual bool isNodalDefined() const override final { return false; }

  virtual void setNodalValue(const OutputType & value, unsigned int idx = 0) override;

  virtual void setDofValue(const OutputData & value, unsigned int index) override;

  void clearDofIndices() override;

  virtual void prepareIC() override;

  virtual const Elem * const & currentElem() const override { return _element_data->currentElem(); }

  virtual void getDofIndices(const Elem * elem,
                             std::vector<dof_id_type> & dof_indices) const override
  {
    return _element_data->getDofIndices(elem, dof_indices);
  }

  virtual const std::vector<dof_id_type> & dofIndices() const final
  {
    return _element_data->dofIndices();
  }
  virtual const std::vector<dof_id_type> & dofIndicesNeighbor() const final
  {
    return _neighbor_data->dofIndices();
  }

  Moose::FV::InterpMethod faceInterpolationMethod() const { return _face_interp_method; }

  void clearAllDofIndices() final;

  const DoFValue & nodalVectorTagValue(TagID) const override
  {
    mooseError("nodalVectorTagValue not implemented for finite volume variables.");
  }
  const DoFValue & nodalMatrixTagValue(TagID) const override
  {
    mooseError("nodalMatrixTagValue not implemented for finite volume variables.");
  }

  const FieldVariableValue & vectorTagValue(TagID tag) const override
  {
    return _element_data->vectorTagValue(tag);
  }
  const DoFValue & vectorTagDofValue(TagID tag) const override
  {
    return _element_data->vectorTagDofValue(tag);
  }
  const FieldVariableValue & matrixTagValue(TagID tag) const override
  {
    return _element_data->matrixTagValue(tag);
  }
  const FieldVariableValue & vectorTagValueNeighbor(TagID tag)
  {
    return _neighbor_data->vectorTagValue(tag);
  }
  const FieldVariableValue & matrixTagValueNeighbor(TagID tag)
  {
    return _neighbor_data->matrixTagValue(tag);
  }

  const FieldVariableValue & uDot() const { return _element_data->uDot(); }
  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 FieldVariableGradient & gradSln() const override
  {
    return _element_data->gradSln(Moose::Current);
  }
  const FieldVariableGradient & gradSlnOld() const override
  {
    return _element_data->gradSln(Moose::Old);
  }
  const FieldVariableValue & uDotNeighbor() const { return _neighbor_data->uDot(); }
  const FieldVariableValue & slnNeighbor() const override
  {
    return _neighbor_data->sln(Moose::Current);
  }
  const FieldVariableValue & slnOldNeighbor() const override
  {
    return _neighbor_data->sln(Moose::Old);
  }
  const FieldVariableGradient & gradSlnNeighbor() const override
  {
    return _neighbor_data->gradSln(Moose::Current);
  }
  const FieldVariableGradient & gradSlnOldNeighbor() const override
  {
    return _neighbor_data->gradSln(Moose::Old);
  }

  const VariableValue & duDotDu() const { return _element_data->duDotDu(); }
  const VariableValue & duDotDotDu() const { return _element_data->duDotDotDu(); }
  const VariableValue & duDotDuNeighbor() const { return _neighbor_data->duDotDu(); }
  const VariableValue & duDotDotDuNeighbor() const { return _neighbor_data->duDotDotDu(); }

  const ADTemplateVariableValue<OutputType> & adSln() const override
  {
    return _element_data->adSln();
  }
  const ADTemplateVariableGradient<OutputType> & adGradSln() const override
  {
    return _element_data->adGradSln();
  }

  virtual const VectorValue<ADReal> & adGradSln(const Elem * const elem,
                                                const StateArg & state,
                                                const bool correct_skewness = false) const;

  virtual VectorValue<ADReal>
  adGradSln(const FaceInfo & fi, const StateArg & state, const bool correct_skewness = false) const;

  virtual VectorValue<ADReal> uncorrectedAdGradSln(const FaceInfo & fi,
                                                   const StateArg & state,
                                                   const bool correct_skewness = false) const;

  ADReal getBoundaryFaceValue(const FaceInfo & fi,
                              const StateArg & state,
                              bool correct_skewness = false) const;

  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
  {
    mooseError("We don't currently implement curl for FV");
  }

  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
  {
    mooseError("We don't currently implement curl for FV");
  }

  virtual void computeElemValues() override;
  virtual void computeFaceValues(const FaceInfo & fi) override;

  virtual void setDofValues(const DenseVector<OutputData> & values) override;
  virtual void setLowerDofValues(const DenseVector<OutputData> & values) override;

  OutputData getElementalValue(const Elem * elem, unsigned int idx = 0) const;
  OutputData getElementalValueOld(const Elem * elem, unsigned int idx = 0) const;
  OutputData 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;

  const DoFValue & dofValues() const override;
  const DoFValue & dofValuesOld() const override;
  const DoFValue & dofValuesOlder() const override;
  const DoFValue & dofValuesPreviousNL() const override;
  const DoFValue & dofValuesNeighbor() const override;
  const DoFValue & dofValuesOldNeighbor() const override;
  const DoFValue & dofValuesOlderNeighbor() const override;
  const DoFValue & dofValuesPreviousNLNeighbor() const override;
  const DoFValue & dofValuesDot() const override;
  const DoFValue & dofValuesDotNeighbor() const override;
  const DoFValue & dofValuesDotOld() const override;
  const DoFValue & dofValuesDotOldNeighbor() const override;
  const DoFValue & dofValuesDotDot() const override;
  const DoFValue & dofValuesDotDotNeighbor() const override;
  const DoFValue & dofValuesDotDotOld() const override;
  const DoFValue & 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 MooseArray<ADReal> & adDofValues() const override;
  const MooseArray<ADReal> & adDofValuesNeighbor() const override;
  const MooseArray<ADReal> & adDofValuesDot() const override;

  OutputType getValue(const Elem * elem) const;

  typename OutputTools<OutputType>::OutputGradient getGradient(const Elem * elem) const;

  bool hasDirichletBC() const
  {
    return _element_data->hasDirichletBC() || _neighbor_data->hasDirichletBC();
  }

  std::pair<bool, const FVDirichletBCBase *> getDirichletBC(const FaceInfo & fi) const;

  std::pair<bool, std::vector<const FVFluxBC *>> getFluxBCs(const FaceInfo & fi) const;

  virtual void residualSetup() override;
  virtual void initialSetup() override;
  virtual void jacobianSetup() override;
  virtual void timestepSetup() override;
  virtual void meshChanged() override;

  ADReal getElemValue(const Elem * elem, const StateArg & state) const;

  void setActiveTags(const std::set<TagID> & vtags) override;

  virtual void requireQpComputations() const {}

  virtual bool isDirichletBoundaryFace(const FaceInfo & fi,
                                       const Elem * elem,
                                       const Moose::StateArg & state) const;

  bool supportsFaceArg() const override final { return true; }
  bool supportsElemSideQpArg() const override final { return true; }

protected:
  virtual ADReal getDirichletBoundaryFaceValue(const FaceInfo & fi,
                                               const Elem * elem,
                                               const Moose::StateArg & state) const;

  bool isExtrapolatedBoundaryFace(const FaceInfo & fi,
                                  const Elem * elem,
                                  const Moose::StateArg & state) const override;

private:
  using MooseVariableField<OutputType>::evaluate;
  using MooseVariableField<OutputType>::evaluateGradient;
  using MooseVariableField<OutputType>::evaluateDot;

  ValueType evaluate(const ElemArg & elem, const StateArg &) const override final;
  ValueType evaluate(const FaceArg & face, const StateArg &) const override final;
  ValueType evaluate(const NodeArg & node, const StateArg &) const override final;
  ValueType evaluate(const ElemPointArg & elem_point, const StateArg & state) const override final;
  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;
  GradientType evaluateGradient(const ElemQpArg & qp_arg, const StateArg &) const override final;
  GradientType evaluateGradient(const ElemArg & elem_arg, const StateArg &) const override final;
  GradientType evaluateGradient(const FaceArg & face, const StateArg &) const override final;
  DotType evaluateDot(const ElemArg & elem, const StateArg &) const override final;
  DotType evaluateDot(const FaceArg & face, const StateArg &) const override final;
  DotType evaluateDot(const ElemQpArg & elem_qp, const StateArg &) const override final;

  void determineBoundaryToDirichletBCMap();

  bool _dirichlet_map_setup = false;

  void determineBoundaryToFluxBCMap();

  bool _flux_map_setup = false;

public:
  const MooseArray<OutputType> & nodalValueArray() const override
  {
    mooseError("Finite volume variables do not have defined values at nodes.");
  }
  const MooseArray<OutputType> & nodalValueOldArray() const override
  {
    mooseError("Finite volume variables do not have defined values at nodes.");
  }
  const MooseArray<OutputType> & nodalValueOlderArray() const override
  {
    mooseError("Finite volume variables do not have defined values at nodes.");
  }

  bool computingSecond() const override final { return false; }
  bool computingCurl() const override final { return false; }
  bool computingDiv() const override final { return false; }
  bool usesSecondPhiNeighbor() const override final { return false; }

  const FieldVariablePhiValue & phi() const override final { return _phi; }
  const FieldVariablePhiGradient & gradPhi() const override final { return _grad_phi; }
  const FieldVariablePhiSecond & secondPhi() const override final
  {
    mooseError("We don't currently implement second derivatives for FV");
  }
  const FieldVariablePhiValue & curlPhi() const override final
  {
    mooseError("We don't currently implement curl for FV");
  }
  const FieldVariablePhiDivergence & divPhi() const override final
  {
    mooseError("We don't currently implement divergence for FV");
  }

  const FieldVariablePhiValue & phiFace() const override final { return _phi_face; }
  const FieldVariablePhiGradient & gradPhiFace() const override final { return _grad_phi_face; }
  const FieldVariablePhiSecond & secondPhiFace() const override final
  {
    mooseError("We don't currently implement second derivatives for FV");
  }

  const FieldVariablePhiValue & phiFaceNeighbor() const override final
  {
    return _phi_face_neighbor;
  }
  const FieldVariablePhiGradient & gradPhiFaceNeighbor() const override final
  {
    return _grad_phi_face_neighbor;
  }
  const FieldVariablePhiSecond & secondPhiFaceNeighbor() const override final
  {
    mooseError("We don't currently implement second derivatives for FV");
  }

  const FieldVariablePhiValue & phiNeighbor() const override final { return _phi_neighbor; }
  const FieldVariablePhiGradient & gradPhiNeighbor() const override final
  {
    return _grad_phi_neighbor;
  }
  const FieldVariablePhiSecond & secondPhiNeighbor() const override final
  {
    mooseError("We don't currently implement second derivatives for FV");
  }

  virtual const FieldVariablePhiValue & phiLower() const override;

  unsigned int oldestSolutionStateRequested() const override final;

  virtual ADReal getExtrapolatedBoundaryFaceValue(const FaceInfo & fi,
                                                  bool two_term_expansion,
                                                  bool correct_skewness,
                                                  const Elem * elem_side_to_extrapolate_from,
                                                  const StateArg & state) const;

  const bool & getTwoTermBoundaryExpansion() const { return _two_term_boundary_expansion; }

protected:
  void clearCaches();

  usingMooseVariableFieldMembers;

  std::unique_ptr<MooseVariableDataFV<OutputType>> _element_data;

  std::unique_ptr<MooseVariableDataFV<OutputType>> _neighbor_data;

private:
  const libMesh::NumericVector<libMesh::Number> * const & _solution;

  const FieldVariablePhiValue & _phi;
  const FieldVariablePhiGradient & _grad_phi;
  const FieldVariablePhiValue & _phi_face;
  const FieldVariablePhiGradient & _grad_phi_face;
  const FieldVariablePhiValue & _phi_face_neighbor;
  const FieldVariablePhiGradient & _grad_phi_face_neighbor;
  const FieldVariablePhiValue & _phi_neighbor;
  const FieldVariablePhiGradient & _grad_phi_neighbor;

  mutable const Elem * _prev_elem;

  std::unordered_map<BoundaryID, const FVDirichletBCBase *> _boundary_id_to_dirichlet_bc;

  std::unordered_map<BoundaryID, std::vector<const FVFluxBC *>> _boundary_id_to_flux_bc;

  [[noreturn]] void lowerDError() const;

protected:
  mutable std::unordered_map<const Elem *, VectorValue<ADReal>> _elem_to_grad;

  bool _two_term_boundary_expansion;

  mutable VectorValue<ADReal> _temp_cell_gradient;

  const bool _cache_cell_gradients;

  Moose::FV::InterpMethod _face_interp_method;

  friend void Moose::initDofIndices<>(MooseVariableFV<OutputType> &, const Elem &);
};

template <typename OutputType>
inline const MooseArray<ADReal> &
MooseVariableFV<OutputType>::adDofValues() const
{
  return _element_data->adDofValues();
}

template <typename OutputType>
inline const MooseArray<ADReal> &
MooseVariableFV<OutputType>::adDofValuesNeighbor() const
{
  return _neighbor_data->adDofValues();
}

template <typename OutputType>
inline const MooseArray<ADReal> &
MooseVariableFV<OutputType>::adDofValuesDot() const
{
  return _element_data->adDofValuesDot();
}

template <typename OutputType>
typename MooseVariableFV<OutputType>::ValueType
MooseVariableFV<OutputType>::evaluate(const ElemArg & elem_arg, const StateArg & state) const
{
  return getElemValue(elem_arg.elem, state);
}

template <typename OutputType>
typename MooseVariableFV<OutputType>::ValueType
MooseVariableFV<OutputType>::evaluate(const ElemPointArg & elem_point, const StateArg & state) const
{
  return (*this)(elem_point.makeElem(), state) +
         (elem_point.point - elem_point.elem->vertex_average()) *
             this->gradient(elem_point.makeElem(), state);
}

template <typename OutputType>
typename MooseVariableFV<OutputType>::ValueType
MooseVariableFV<OutputType>::evaluate(const ElemQpArg & elem_qp, const StateArg & state) const
{
  return (*this)(ElemPointArg{elem_qp.elem,
                              elem_qp.point,
                              _face_interp_method == Moose::FV::InterpMethod::SkewCorrectedAverage},
                 state);
}

template <typename OutputType>
typename MooseVariableFV<OutputType>::ValueType
MooseVariableFV<OutputType>::evaluate(const ElemSideQpArg & elem_side_qp,
                                      const StateArg & state) const
{
  return (*this)(ElemPointArg{elem_side_qp.elem,
                              elem_side_qp.point,
                              _face_interp_method == Moose::FV::InterpMethod::SkewCorrectedAverage},
                 state);
}

template <typename OutputType>
typename MooseVariableFV<OutputType>::GradientType
MooseVariableFV<OutputType>::evaluateGradient(const ElemQpArg & qp_arg,
                                              const StateArg & state) const
{
  return adGradSln(
      qp_arg.elem, state, _face_interp_method == Moose::FV::InterpMethod::SkewCorrectedAverage);
}

template <typename OutputType>
typename MooseVariableFV<OutputType>::GradientType
MooseVariableFV<OutputType>::evaluateGradient(const ElemArg & elem_arg,
                                              const StateArg & state) const
{
  return adGradSln(elem_arg.elem, state, elem_arg.correct_skewness);
}

template <typename OutputType>
typename MooseVariableFV<OutputType>::GradientType
MooseVariableFV<OutputType>::evaluateGradient(const FaceArg & face, const StateArg & state) const
{
  mooseAssert(face.fi, "We must have a non-null face information");
  return adGradSln(*face.fi, state, face.correct_skewness);
}

template <typename OutputType>
void
MooseVariableFV<OutputType>::setActiveTags(const std::set<TagID> & vtags)
{
  _element_data->setActiveTags(vtags);
  _neighbor_data->setActiveTags(vtags);
}

template <typename OutputType>
const std::vector<dof_id_type> &
MooseVariableFV<OutputType>::dofIndicesLower() const
{
  static const std::vector<dof_id_type> empty;
  return empty;
}

template <typename OutputType>
void
MooseVariableFV<OutputType>::initialSetup()
{
  determineBoundaryToDirichletBCMap();
  determineBoundaryToFluxBCMap();
  MooseVariableField<OutputType>::initialSetup();
}

template <typename OutputType>
void
MooseVariableFV<OutputType>::meshChanged()
{
  _prev_elem = nullptr;
  _dirichlet_map_setup = false;
  _flux_map_setup = false;
  MooseVariableField<OutputType>::meshChanged();
}

template <typename OutputType>
void
MooseVariableFV<OutputType>::timestepSetup()
{
  _dirichlet_map_setup = false;
  _flux_map_setup = false;
  MooseVariableField<OutputType>::timestepSetup();
}

template <typename OutputType>
const typename MooseVariableFV<OutputType>::FieldVariablePhiValue &
MooseVariableFV<OutputType>::phiLower() const
{
  lowerDError();
}

template <typename OutputType>
void
MooseVariableFV<OutputType>::lowerDError() const
{
  mooseError("Lower dimensional element support not implemented for finite volume variables");
}

// Declare all the specializations, as the template specialization declaration below must know
template <>
ADReal MooseVariableFV<Real>::evaluateDot(const ElemArg & elem, const StateArg & state) const;
template <>
ADReal MooseVariableFV<Real>::evaluateDot(const FaceArg & elem_arg, const StateArg & state) const;
template <>
ADReal MooseVariableFV<Real>::evaluateDot(const ElemQpArg & elem_arg, const StateArg & state) const;

// Prevent implicit instantiation in other translation units where these classes are used
extern template class MooseVariableFV<Real>;