Assembly.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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 "MooseArray.h"
#include "MooseTypes.h"

#include "libmesh/dense_matrix.h"
#include "libmesh/dense_vector.h"
#include "libmesh/enum_quadrature_type.h"
#include "libmesh/fe_type.h"
#include "libmesh/point.h"

#include "metaphysicl/numberarray.h"
#include "metaphysicl/dualnumber.h"

// libMesh forward declarations
namespace libMesh
{
class DofMap;
class CouplingMatrix;
class Elem;
template <typename>
class VectorValue;
typedef VectorValue<Real> RealVectorValue;
template <typename T>
class FEGenericBase;
typedef FEGenericBase<Real> FEBase;
typedef FEGenericBase<VectorValue<Real>> FEVectorBase;
class Node;
template <typename T>
class NumericVector;
template <typename T>
class SparseMatrix;
}

// MOOSE Forward Declares
class MooseMesh;
class ArbitraryQuadrature;
class SystemBase;
class MooseVariableFEBase;
class MooseVariableBase;
template <typename>
class MooseVariableFE;
class MooseVariableScalar;
typedef MooseVariableFE<Real> MooseVariable;
typedef MooseVariableFE<RealVectorValue> VectorMooseVariable;
class XFEMInterface;
class SubProblem;

class Assembly
{
public:
  Assembly(SystemBase & sys, THREAD_ID tid);
  virtual ~Assembly();

  const FEBase * const & getFE(FEType type, unsigned int dim) const
  {
    buildFE(type);
    return _const_fe[dim][type];
  }

  const FEBase * const & getFENeighbor(FEType type, unsigned int dim) const
  {
    buildNeighborFE(type);
    return _const_fe_neighbor[dim][type];
  }

  const FEBase * const & getFEFace(FEType type, unsigned int dim) const
  {
    buildFaceFE(type);
    return _const_fe_face[dim][type];
  }

  const FEBase * const & getFEFaceNeighbor(FEType type, unsigned int dim) const
  {
    buildFaceNeighborFE(type);
    return _const_fe_face_neighbor[dim][type];
  }

  const FEVectorBase * const & getVectorFE(FEType type, unsigned int dim) const
  {
    buildVectorFE(type);
    return _const_vector_fe[dim][type];
  }

  const FEVectorBase * const & getVectorFENeighbor(FEType type, unsigned int dim) const
  {
    buildVectorNeighborFE(type);
    return _const_vector_fe_neighbor[dim][type];
  }

  const FEVectorBase * const & getVectorFEFace(FEType type, unsigned int dim) const
  {
    buildVectorFaceFE(type);
    return _const_vector_fe_face[dim][type];
  }

  const FEVectorBase * const & getVectorFEFaceNeighbor(FEType type, unsigned int dim) const
  {
    buildVectorFaceNeighborFE(type);
    return _const_vector_fe_face_neighbor[dim][type];
  }

  const QBase * const & qRule() const { return _const_current_qrule; }

  QBase * const & writeableQRule() { return _current_qrule; }

  const MooseArray<Point> & qPoints() const { return _current_q_points; }

  const MooseArray<Point> & physicalPoints() const { return _current_physical_points; }

  const MooseArray<Real> & JxW() const { return _current_JxW; }

  template <ComputeStage compute_stage>
  const MooseArray<ADReal> & adJxW() const
  {
    return _ad_JxW;
  }

  template <ComputeStage compute_stage>
  const MooseArray<ADReal> & adJxWFace() const
  {
    return _current_JxW_face;
  }

  template <ComputeStage compute_stage>
  const MooseArray<ADReal> & adCurvatures() const;

  const MooseArray<Real> & coordTransformation() const { return _coord; }

  template <ComputeStage compute_stage>
  const MooseArray<ADReal> & adCoordTransformation() const
  {
    return _coord;
  }

  const Moose::CoordinateSystemType & coordSystem() { return _coord_type; }

  const QBase * const & qRuleFace() const { return _const_current_qrule_face; }

  QBase * const & writeableQRuleFace() { return _current_qrule_face; }

  const MooseArray<Point> & qPointsFace() const { return _current_q_points_face; }

  const MooseArray<Real> & JxWFace() const { return _current_JxW_face; }

  const MooseArray<Point> & normals() const { return _current_normals; }

  template <ComputeStage compute_stage>
  const ADPoint & adNormals() const
  {
    return _current_normals;
  }

  template <ComputeStage compute_stage>
  const ADPoint & adQPoints() const
  {
    return _current_q_points;
  }

  template <ComputeStage compute_stage>
  const ADPoint & adQPointsFace() const
  {
    return _current_q_points_face;
  }

  const Elem * const & elem() const { return _current_elem; }

  const SubdomainID & currentSubdomainID() const { return _current_subdomain_id; }

  void setCurrentSubdomainID(SubdomainID i) { _current_subdomain_id = i; }

  const Real & elemVolume() { return _current_elem_volume; }

  const unsigned int & side() const { return _current_side; }

  const unsigned int & neighborSide() const { return _current_neighbor_side; }

  const Elem *& sideElem() { return _current_side_elem; }

  const Real & sideElemVolume() { return _current_side_volume; }

  const Elem * const & neighbor() const { return _current_neighbor_elem; }

  const Elem * const & lowerDElem() const { return _current_lower_d_elem; }

  const SubdomainID & currentNeighborSubdomainID() const { return _current_neighbor_subdomain_id; }

  void setCurrentNeighborSubdomainID(SubdomainID i) { _current_neighbor_subdomain_id = i; }

  const Real & neighborVolume() const;

  const QBase * const & qRuleNeighbor() const { return _const_current_qrule_neighbor; }

  QBase * const & writeableQRuleNeighbor() { return _current_qrule_neighbor; }

  const MooseArray<Real> & JxWNeighbor() const { return _current_JxW_neighbor; }

  const MooseArray<Point> & qPointsFaceNeighbor() const { return _current_q_points_face_neighbor; }

  const Node * const & node() const { return _current_node; }

  const Node * const & nodeNeighbor() const { return _current_neighbor_node; }

  void createQRules(QuadratureType type, Order order, Order volume_order, Order face_order);

  void setVolumeQRule(QBase * qrule, unsigned int dim);

  void setFaceQRule(QBase * qrule, unsigned int dim);

  void setNeighborQRule(QBase * qrule, unsigned int dim);

  void reinit(const Elem * elem);

  void reinitElemFaceRef(const Elem * elem,
                         unsigned int elem_side,
                         Real tolerance,
                         const std::vector<Point> * const pts = nullptr,
                         const std::vector<Real> * const weights = nullptr);

  void reinitNeighborFaceRef(const Elem * neighbor_elem,
                             unsigned int neighbor_side,
                             Real tolerance,
                             const std::vector<Point> * const pts,
                             const std::vector<Real> * const weights = nullptr);

  void reinitLowerDElemRef(const Elem * elem,
                           const std::vector<Point> * const pts,
                           const std::vector<Real> * const weights = nullptr);

  void reinitMortarElem(const Elem * elem);

  const std::vector<Real> & jxWMortar() const { return *_JxW_msm; }

  const QBase * const & qRuleMortar() const { return _const_qrule_msm; }

private:
  void computeADFace(const Elem * elem, unsigned int side);

public:
  void reinitAtPhysical(const Elem * elem, const std::vector<Point> & physical_points);

  void reinit(const Elem * elem, const std::vector<Point> & reference_points);

  void reinit(const Elem * elem, unsigned int side);

  void reinit(const Elem * elem, unsigned int side, const std::vector<Point> & reference_points);

  void reinitElemAndNeighbor(const Elem * elem,
                             unsigned int side,
                             const Elem * neighbor,
                             unsigned int neighbor_side);

  void reinitNeighborAtPhysical(const Elem * neighbor,
                                unsigned int neighbor_side,
                                const std::vector<Point> & physical_points);

  void reinitNeighborAtPhysical(const Elem * neighbor, const std::vector<Point> & physical_points);

  void reinitNeighbor(const Elem * neighbor, const std::vector<Point> & reference_points);

  void reinit(const Node * node);

  void init(const CouplingMatrix * cm);

  void init();

  void initNonlocalCoupling();

  void prepareJacobianBlock();

  void prepareResidual();

  void prepare();
  void prepareNonlocal();

  void prepareVariable(MooseVariableFEBase * var);
  void prepareVariableNonlocal(MooseVariableFEBase * var);
  void prepareNeighbor();

  void prepareLowerD();

  void prepareBlock(unsigned int ivar, unsigned jvar, const std::vector<dof_id_type> & dof_indices);
  void prepareBlockNonlocal(unsigned int ivar,
                            unsigned jvar,
                            const std::vector<dof_id_type> & idof_indices,
                            const std::vector<dof_id_type> & jdof_indices);
  void prepareScalar();
  void prepareOffDiagScalar();

  template <typename T>
  void copyShapes(MooseVariableFE<T> & v);
  void copyShapes(unsigned int var);

  template <typename T>
  void copyFaceShapes(MooseVariableFE<T> & v);
  void copyFaceShapes(unsigned int var);

  template <typename T>
  void copyNeighborShapes(MooseVariableFE<T> & v);
  void copyNeighborShapes(unsigned int var);

  void addResidual(NumericVector<Number> & residual, TagID tag_id = 0);
  void addResidual(const std::map<TagName, TagID> & tags);
  void addResidualNeighbor(NumericVector<Number> & residual, TagID tag_id = 0);
  void addResidualNeighbor(const std::map<TagName, TagID> & tags);
  void addResidualScalar(TagID tag_id);
  void addResidualScalar(const std::map<TagName, TagID> & tags);

  void cacheResidual();

  void cacheResidualContribution(dof_id_type dof, Real value, TagID tag_id);

  void cacheResidualContribution(dof_id_type dof, Real value, const std::set<TagID> & tags);

  void cacheResidualNodes(const DenseVector<Number> & res,
                          const std::vector<dof_id_type> & dof_index,
                          TagID tag = 0);

  void cacheResidualNeighbor();

  void cacheResidualLower();

  void addCachedResiduals();

  void addCachedResidual(NumericVector<Number> & residual, TagID tag_id);

  void setResidual(NumericVector<Number> & residual, TagID tag_id = 0);
  void setResidualNeighbor(NumericVector<Number> & residual, TagID tag_id = 0);

  void addJacobian();
  void addJacobianCoupledVarPair(MooseVariableBase * ivar, MooseVariableBase * jvar);
  void addJacobianNonlocal();
  void addJacobianBlock(SparseMatrix<Number> & jacobian,
                        unsigned int ivar,
                        unsigned int jvar,
                        const DofMap & dof_map,
                        std::vector<dof_id_type> & dof_indices);
  void addJacobianBlockNonlocal(SparseMatrix<Number> & jacobian,
                                unsigned int ivar,
                                unsigned int jvar,
                                const DofMap & dof_map,
                                const std::vector<dof_id_type> & idof_indices,
                                const std::vector<dof_id_type> & jdof_indices);

  void addJacobianNeighbor();

  void addJacobianLower();

  void addJacobianNeighbor(SparseMatrix<Number> & jacobian,
                           unsigned int ivar,
                           unsigned int jvar,
                           const DofMap & dof_map,
                           std::vector<dof_id_type> & dof_indices,
                           std::vector<dof_id_type> & neighbor_dof_indices);
  void addJacobianScalar();
  void addJacobianOffDiagScalar(unsigned int ivar);

  void cacheJacobian();

  void cacheJacobianCoupledVarPair(MooseVariableBase * ivar, MooseVariableBase * jvar);

  void cacheJacobianNonlocal();

  void cacheJacobianNeighbor();

  void addCachedJacobian(SparseMatrix<Number> & jacobian);

  void addCachedJacobian();

  DenseVector<Number> & residualBlock(unsigned int var_num, TagID tag_id = 0)
  {
    return _sub_Re[tag_id][var_num];
  }

  DenseVector<Number> & residualBlockNeighbor(unsigned int var_num, TagID tag_id = 0)
  {
    return _sub_Rn[tag_id][var_num];
  }

  DenseVector<Number> & residualBlockLower(unsigned int var_num, TagID tag_id = 0)
  {
    return _sub_Rl[tag_id][var_num];
  }

  DenseMatrix<Number> & jacobianBlock(unsigned int ivar, unsigned int jvar, TagID tag = 0);

  DenseMatrix<Number> & jacobianBlockNonlocal(unsigned int ivar, unsigned int jvar, TagID tag = 0);
  DenseMatrix<Number> & jacobianBlockNeighbor(Moose::DGJacobianType type,
                                              unsigned int ivar,
                                              unsigned int jvar,
                                              TagID tag = 0);

  DenseMatrix<Number> & jacobianBlockLower(Moose::ConstraintJacobianType type,
                                           unsigned int ivar,
                                           unsigned int jvar,
                                           TagID tag = 0);

  void cacheJacobianBlock(DenseMatrix<Number> & jac_block,
                          const std::vector<dof_id_type> & idof_indices,
                          const std::vector<dof_id_type> & jdof_indices,
                          Real scaling_factor,
                          TagID tag = 0);
  void cacheJacobianBlockNonlocal(DenseMatrix<Number> & jac_block,
                                  const std::vector<dof_id_type> & idof_indices,
                                  const std::vector<dof_id_type> & jdof_indices,
                                  Real scaling_factor,
                                  TagID tag = 0);

  std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *>> & couplingEntries()
  {
    return _cm_ff_entry;
  }
  std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *>> & nonlocalCouplingEntries()
  {
    return _cm_nonlocal_entry;
  }

  // Read-only references
  const VariablePhiValue & phi() const { return _phi; }
  template <typename T, ComputeStage compute_stage>
  const typename VariableTestGradientType<T, compute_stage>::type &
  adGradPhi(const MooseVariableFE<T> & v) const
  {
    return gradPhi(v);
  }
  const VariablePhiValue & phi(const MooseVariable &) const { return _phi; }
  const VariablePhiGradient & gradPhi() const { return _grad_phi; }
  const VariablePhiGradient & gradPhi(const MooseVariable &) const { return _grad_phi; }
  const VariablePhiSecond & secondPhi() const { return _second_phi; }
  const VariablePhiSecond & secondPhi(const MooseVariable &) const { return _second_phi; }

  const VariablePhiValue & phiFace() const { return _phi_face; }
  const VariablePhiValue & phiFace(const MooseVariable &) const { return _phi_face; }
  const VariablePhiGradient & gradPhiFace() const { return _grad_phi_face; }
  const VariablePhiGradient & gradPhiFace(const MooseVariable &) const { return _grad_phi_face; }
  const VariablePhiSecond & secondPhiFace(const MooseVariable &) const { return _second_phi_face; }

  const VariablePhiValue & phiNeighbor(const MooseVariable &) const { return _phi_neighbor; }
  const VariablePhiGradient & gradPhiNeighbor(const MooseVariable &) const
  {
    return _grad_phi_neighbor;
  }
  const VariablePhiSecond & secondPhiNeighbor(const MooseVariable &) const
  {
    return _second_phi_neighbor;
  }

  const VariablePhiValue & phiFaceNeighbor(const MooseVariable &) const
  {
    return _phi_face_neighbor;
  }
  const VariablePhiGradient & gradPhiFaceNeighbor(const MooseVariable &) const
  {
    return _grad_phi_face_neighbor;
  }
  const VariablePhiSecond & secondPhiFaceNeighbor(const MooseVariable &) const
  {
    return _second_phi_face_neighbor;
  }

  const VectorVariablePhiValue & phi(const VectorMooseVariable &) const { return _vector_phi; }
  const VectorVariablePhiGradient & gradPhi(const VectorMooseVariable &) const
  {
    return _vector_grad_phi;
  }
  const VectorVariablePhiSecond & secondPhi(const VectorMooseVariable &) const
  {
    return _vector_second_phi;
  }
  const VectorVariablePhiCurl & curlPhi(const VectorMooseVariable &) const
  {
    return _vector_curl_phi;
  }

  const VectorVariablePhiValue & phiFace(const VectorMooseVariable &) const
  {
    return _vector_phi_face;
  }
  const VectorVariablePhiGradient & gradPhiFace(const VectorMooseVariable &) const
  {
    return _vector_grad_phi_face;
  }
  const VectorVariablePhiSecond & secondPhiFace(const VectorMooseVariable &) const
  {
    return _vector_second_phi_face;
  }
  const VectorVariablePhiCurl & curlPhiFace(const VectorMooseVariable &) const
  {
    return _vector_curl_phi_face;
  }

  const VectorVariablePhiValue & phiNeighbor(const VectorMooseVariable &) const
  {
    return _vector_phi_neighbor;
  }
  const VectorVariablePhiGradient & gradPhiNeighbor(const VectorMooseVariable &) const
  {
    return _vector_grad_phi_neighbor;
  }
  const VectorVariablePhiSecond & secondPhiNeighbor(const VectorMooseVariable &) const
  {
    return _vector_second_phi_neighbor;
  }
  const VectorVariablePhiCurl & curlPhiNeighbor(const VectorMooseVariable &) const
  {
    return _vector_curl_phi_neighbor;
  }

  const VectorVariablePhiValue & phiFaceNeighbor(const VectorMooseVariable &) const
  {
    return _vector_phi_face_neighbor;
  }
  const VectorVariablePhiGradient & gradPhiFaceNeighbor(const VectorMooseVariable &) const
  {
    return _vector_grad_phi_face_neighbor;
  }
  const VectorVariablePhiSecond & secondPhiFaceNeighbor(const VectorMooseVariable &) const
  {
    return _vector_second_phi_face_neighbor;
  }
  const VectorVariablePhiCurl & curlPhiFaceNeighbor(const VectorMooseVariable &) const
  {
    return _vector_curl_phi_face_neighbor;
  }

  // Writeable references
  VariablePhiValue & phi(const MooseVariable &) { return _phi; }
  VariablePhiGradient & gradPhi(const MooseVariable &) { return _grad_phi; }
  VariablePhiSecond & secondPhi(const MooseVariable &) { return _second_phi; }

  VariablePhiValue & phiFace(const MooseVariable &) { return _phi_face; }
  VariablePhiGradient & gradPhiFace(const MooseVariable &) { return _grad_phi_face; }
  VariablePhiSecond & secondPhiFace(const MooseVariable &) { return _second_phi_face; }

  VariablePhiValue & phiNeighbor(const MooseVariable &) { return _phi_neighbor; }
  VariablePhiGradient & gradPhiNeighbor(const MooseVariable &) { return _grad_phi_neighbor; }
  VariablePhiSecond & secondPhiNeighbor(const MooseVariable &) { return _second_phi_neighbor; }

  VariablePhiValue & phiFaceNeighbor(const MooseVariable &) { return _phi_face_neighbor; }
  VariablePhiGradient & gradPhiFaceNeighbor(const MooseVariable &)
  {
    return _grad_phi_face_neighbor;
  }
  VariablePhiSecond & secondPhiFaceNeighbor(const MooseVariable &)
  {
    return _second_phi_face_neighbor;
  }

  VectorVariablePhiValue & phi(const VectorMooseVariable &) { return _vector_phi; }
  VectorVariablePhiGradient & gradPhi(const VectorMooseVariable &) { return _vector_grad_phi; }
  VectorVariablePhiSecond & secondPhi(const VectorMooseVariable &) { return _vector_second_phi; }
  VectorVariablePhiCurl & curlPhi(const VectorMooseVariable &) { return _vector_curl_phi; }

  VectorVariablePhiValue & phiFace(const VectorMooseVariable &) { return _vector_phi_face; }
  VectorVariablePhiGradient & gradPhiFace(const VectorMooseVariable &)
  {
    return _vector_grad_phi_face;
  }
  VectorVariablePhiSecond & secondPhiFace(const VectorMooseVariable &)
  {
    return _vector_second_phi_face;
  }
  VectorVariablePhiCurl & curlPhiFace(const VectorMooseVariable &) { return _vector_curl_phi_face; }

  VectorVariablePhiValue & phiNeighbor(const VectorMooseVariable &) { return _vector_phi_neighbor; }
  VectorVariablePhiGradient & gradPhiNeighbor(const VectorMooseVariable &)
  {
    return _vector_grad_phi_neighbor;
  }
  VectorVariablePhiSecond & secondPhiNeighbor(const VectorMooseVariable &)
  {
    return _vector_second_phi_neighbor;
  }
  VectorVariablePhiCurl & curlPhiNeighbor(const VectorMooseVariable &)
  {
    return _vector_curl_phi_neighbor;
  }

  VectorVariablePhiValue & phiFaceNeighbor(const VectorMooseVariable &)
  {
    return _vector_phi_face_neighbor;
  }
  VectorVariablePhiGradient & gradPhiFaceNeighbor(const VectorMooseVariable &)
  {
    return _vector_grad_phi_face_neighbor;
  }
  VectorVariablePhiSecond & secondPhiFaceNeighbor(const VectorMooseVariable &)
  {
    return _vector_second_phi_face_neighbor;
  }
  VectorVariablePhiCurl & curlPhiFaceNeighbor(const VectorMooseVariable &)
  {
    return _vector_curl_phi_face_neighbor;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiValue & fePhi(FEType type) const
  {
    buildFE(type);
    return _fe_shape_data[type]->_phi;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiGradient & feGradPhi(FEType type) const
  {
    buildFE(type);
    return _fe_shape_data[type]->_grad_phi;
  }

  template <typename OutputType>
  const typename VariableTestGradientType<OutputType, ComputeStage::JACOBIAN>::type &
  feADGradPhi(FEType type) const
  {
    return _ad_grad_phi_data[type];
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiSecond & feSecondPhi(FEType type) const
  {
    _need_second_derivative[type] = true;
    buildFE(type);
    return _fe_shape_data[type]->_second_phi;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiValue & fePhiLower(FEType type) const;

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiGradient & feGradPhiLower(FEType type) const;

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiValue & fePhiFace(FEType type) const
  {
    buildFaceFE(type);
    return _fe_shape_data_face[type]->_phi;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiGradient & feGradPhiFace(FEType type) const
  {
    buildFaceFE(type);
    return _fe_shape_data_face[type]->_grad_phi;
  }

  template <typename OutputType>
  const typename VariableTestGradientType<OutputType, ComputeStage::JACOBIAN>::type &
  feADGradPhiFace(FEType type) const
  {
    return _ad_grad_phi_data_face[type];
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiSecond & feSecondPhiFace(FEType type) const
  {
    _need_second_derivative[type] = true;
    buildFaceFE(type);
    return _fe_shape_data_face[type]->_second_phi;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiValue & fePhiNeighbor(FEType type) const
  {
    buildNeighborFE(type);
    return _fe_shape_data_neighbor[type]->_phi;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiGradient & feGradPhiNeighbor(FEType type) const
  {
    buildNeighborFE(type);
    return _fe_shape_data_neighbor[type]->_grad_phi;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiSecond & feSecondPhiNeighbor(FEType type) const
  {
    _need_second_derivative_neighbor[type] = true;
    buildNeighborFE(type);
    return _fe_shape_data_neighbor[type]->_second_phi;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiValue & fePhiFaceNeighbor(FEType type) const
  {
    buildFaceNeighborFE(type);
    return _fe_shape_data_face_neighbor[type]->_phi;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiGradient &
  feGradPhiFaceNeighbor(FEType type) const
  {
    buildFaceNeighborFE(type);
    return _fe_shape_data_face_neighbor[type]->_grad_phi;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiSecond &
  feSecondPhiFaceNeighbor(FEType type) const
  {
    _need_second_derivative_neighbor[type] = true;
    buildFaceNeighborFE(type);
    return _fe_shape_data_face_neighbor[type]->_second_phi;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiCurl & feCurlPhi(FEType type) const
  {
    _need_curl[type] = true;
    buildFE(type);
    return _fe_shape_data[type]->_curl_phi;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiCurl & feCurlPhiFace(FEType type) const
  {
    _need_curl[type] = true;
    buildFaceFE(type);
    return _fe_shape_data_face[type]->_curl_phi;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiCurl & feCurlPhiNeighbor(FEType type) const
  {
    _need_curl[type] = true;
    buildNeighborFE(type);
    return _fe_shape_data_neighbor[type]->_curl_phi;
  }

  template <typename OutputType>
  const typename OutputTools<OutputType>::VariablePhiCurl & feCurlPhiFaceNeighbor(FEType type) const
  {
    _need_curl[type] = true;
    buildFaceNeighborFE(type);
    return _fe_shape_data_face_neighbor[type]->_curl_phi;
  }

  void
  cacheJacobianContribution(numeric_index_type i, numeric_index_type j, Real value, TagID tag = 0);

  void cacheJacobianContribution(numeric_index_type i,
                                 numeric_index_type j,
                                 Real value,
                                 const std::set<TagID> & tags);

  void setCachedJacobianContributions();

  void zeroCachedJacobianContributions();

  void addCachedJacobianContributions();

  void setXFEM(std::shared_ptr<XFEMInterface> xfem) { _xfem = xfem; }

  void assignDisplacements(std::vector<unsigned> && disp_numbers) { _displacements = disp_numbers; }

protected:
  void reinitFE(const Elem * elem);

  void reinitFEFace(const Elem * elem, unsigned int side);

  void computeFaceMap(unsigned dim, const std::vector<Real> & qw, const Elem * side);

  void reinitFEFaceNeighbor(const Elem * neighbor, const std::vector<Point> & reference_points);

  void reinitFENeighbor(const Elem * neighbor, const std::vector<Point> & reference_points);

  template <ComputeStage compute_stage>
  void setCoordinateTransformation(const QBase * qrule,
                                   const ADPoint & q_points,
                                   MooseArray<ADReal> & coord);

  void computeCurrentElemVolume();

  void computeCurrentFaceVolume();

  void computeCurrentNeighborVolume();

  void addResidualBlock(NumericVector<Number> & residual,
                        DenseVector<Number> & res_block,
                        const std::vector<dof_id_type> & dof_indices,
                        Real scaling_factor);
  void cacheResidualBlock(std::vector<Real> & cached_residual_values,
                          std::vector<dof_id_type> & cached_residual_rows,
                          DenseVector<Number> & res_block,
                          const std::vector<dof_id_type> & dof_indices,
                          Real scaling_factor);

  void setResidualBlock(NumericVector<Number> & residual,
                        DenseVector<Number> & res_block,
                        const std::vector<dof_id_type> & dof_indices,
                        Real scaling_factor);

  void addJacobianBlock(SparseMatrix<Number> & jacobian,
                        DenseMatrix<Number> & jac_block,
                        const std::vector<dof_id_type> & idof_indices,
                        const std::vector<dof_id_type> & jdof_indices,
                        Real scaling_factor);

  void clearCachedJacobianContributions();

  void modifyWeightsDueToXFEM(const Elem * elem);

  void modifyFaceWeightsDueToXFEM(const Elem * elem, unsigned int side = 0);

  template <typename OutputType>
  void computeGradPhiAD(
      const Elem * elem,
      unsigned int n_qp,
      typename VariableTestGradientType<OutputType, ComputeStage::JACOBIAN>::type & grad_phi,
      FEGenericBase<OutputType> * fe);
  void resizeMappingObjects(unsigned int n_qp, unsigned int dim);
  void computeAffineMapAD(const Elem * elem,
                          const std::vector<Real> & qw,
                          unsigned int n_qp,
                          FEBase * fe);
  void
  computeSinglePointMapAD(const Elem * elem, const std::vector<Real> & qw, unsigned p, FEBase * fe);

private:
  void buildFE(FEType type) const;

  void buildFaceFE(FEType type) const;

  void buildNeighborFE(FEType type) const;

  void buildFaceNeighborFE(FEType type) const;

  void buildLowerDFE(FEType type) const;

  void buildVectorFE(FEType type) const;

  void buildVectorFaceFE(FEType type) const;

  void buildVectorNeighborFE(FEType type) const;

  void buildVectorFaceNeighborFE(FEType type) const;

  void buildVectorLowerDFE(FEType type) const;

private:
  SystemBase & _sys;
  SubProblem & _subproblem;

  const bool _displaced;

  const CouplingMatrix * _cm;
  const CouplingMatrix & _nonlocal_cm;

  const bool & _computing_jacobian;

  std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *>> _cm_ff_entry;
  std::vector<std::pair<MooseVariableFEBase *, MooseVariableScalar *>> _cm_fs_entry;
  std::vector<std::pair<MooseVariableScalar *, MooseVariableFEBase *>> _cm_sf_entry;
  std::vector<std::pair<MooseVariableScalar *, MooseVariableScalar *>> _cm_ss_entry;
  std::vector<std::pair<MooseVariableFEBase *, MooseVariableFEBase *>> _cm_nonlocal_entry;
  std::vector<std::vector<std::vector<unsigned char>>> _jacobian_block_used;
  std::vector<std::vector<std::vector<unsigned char>>> _jacobian_block_nonlocal_used;
  std::vector<std::vector<std::vector<unsigned char>>> _jacobian_block_neighbor_used;
  std::vector<std::vector<std::vector<unsigned char>>> _jacobian_block_lower_used;
  const DofMap & _dof_map;
  THREAD_ID _tid;

  MooseMesh & _mesh;

  unsigned int _mesh_dimension;

  std::shared_ptr<XFEMInterface> _xfem;

  std::map<FEType, FEBase *> _current_fe;
  std::map<FEType, FEBase *> _current_fe_face;
  std::map<FEType, FEBase *> _current_fe_neighbor;
  std::map<FEType, FEBase *> _current_fe_face_neighbor;

  std::map<FEType, FEVectorBase *> _current_vector_fe;
  std::map<FEType, FEVectorBase *> _current_vector_fe_face;
  std::map<FEType, FEVectorBase *> _current_vector_fe_neighbor;
  std::map<FEType, FEVectorBase *> _current_vector_fe_face_neighbor;

  /**** Volume Stuff ****/

  mutable std::map<unsigned int, std::map<FEType, FEBase *>> _fe;
  mutable std::map<unsigned int, std::map<FEType, const FEBase *>> _const_fe;
  mutable std::map<unsigned int, std::map<FEType, FEVectorBase *>> _vector_fe;
  mutable std::map<unsigned int, std::map<FEType, const FEVectorBase *>> _const_vector_fe;
  std::map<unsigned int, FEBase **> _holder_fe_helper;
  FEBase * _current_fe_helper;
  const QBase * _const_current_qrule;
  QBase * _current_qrule;
  QBase * _current_qrule_volume;
  ArbitraryQuadrature * _current_qrule_arbitrary;
  ArbitraryQuadrature * _current_qrule_arbitrary_face;
  MooseArray<Point> _current_q_points;
  MooseArray<Real> _current_JxW;
  Moose::CoordinateSystemType _coord_type;
  MooseArray<Real> _coord;
  MooseArray<DualReal> _ad_coord;

  std::map<unsigned int, QBase *> _holder_qrule_volume;
  std::map<unsigned int, ArbitraryQuadrature *> _holder_qrule_arbitrary;
  std::map<unsigned int, ArbitraryQuadrature *> _holder_qrule_arbitrary_face;
  std::map<unsigned int, const std::vector<Point> *> _holder_q_points;
  std::map<unsigned int, const std::vector<Real> *> _holder_JxW;

  /**** Face Stuff ****/

  mutable std::map<unsigned int, std::map<FEType, FEBase *>> _fe_face;
  mutable std::map<unsigned int, std::map<FEType, const FEBase *>> _const_fe_face;
  mutable std::map<unsigned int, std::map<FEType, FEVectorBase *>> _vector_fe_face;
  mutable std::map<unsigned int, std::map<FEType, const FEVectorBase *>> _const_vector_fe_face;
  std::map<unsigned int, FEBase **> _holder_fe_face_helper;
  FEBase * _current_fe_face_helper;
  const QBase * _const_current_qrule_face;
  QBase * _current_qrule_face;
  ArbitraryQuadrature * _current_qface_arbitrary;
  MooseArray<Point> _current_q_points_face;
  MooseArray<Real> _current_JxW_face;
  MooseArray<Point> _current_normals;
  std::map<unsigned int, QBase *> _holder_qrule_face;
  std::map<unsigned int, const std::vector<Point> *> _holder_q_points_face;
  std::map<unsigned int, const std::vector<Real> *> _holder_JxW_face;
  std::map<unsigned int, const std::vector<Point> *> _holder_normals;

  /**** Neighbor Stuff ****/

  mutable std::map<unsigned int, std::map<FEType, FEBase *>> _fe_neighbor;
  mutable std::map<unsigned int, std::map<FEType, FEBase *>> _fe_face_neighbor;
  mutable std::map<unsigned int, std::map<FEType, FEVectorBase *>> _vector_fe_neighbor;
  mutable std::map<unsigned int, std::map<FEType, FEVectorBase *>> _vector_fe_face_neighbor;
  mutable std::map<unsigned int, std::map<FEType, const FEBase *>> _const_fe_neighbor;
  mutable std::map<unsigned int, std::map<FEType, const FEBase *>> _const_fe_face_neighbor;
  mutable std::map<unsigned int, std::map<FEType, const FEVectorBase *>> _const_vector_fe_neighbor;
  mutable std::map<unsigned int, std::map<FEType, const FEVectorBase *>>
      _const_vector_fe_face_neighbor;

  std::map<unsigned int, FEBase **> _holder_fe_neighbor_helper;
  std::map<unsigned int, FEBase **> _holder_fe_face_neighbor_helper;

  mutable std::map<unsigned int, std::map<FEType, FEBase *>> _fe_lower;
  mutable std::map<unsigned int, std::map<FEType, const FEBase *>> _const_fe_lower;
  mutable std::map<unsigned int, std::map<FEType, FEVectorBase *>> _vector_fe_lower;
  mutable std::map<unsigned int, std::map<FEType, const FEVectorBase *>> _const_vector_fe_lower;

  const QBase * _const_current_qrule_neighbor;
  QBase * _current_qrule_neighbor;
  MooseArray<Point> _current_q_points_face_neighbor;
  std::map<unsigned int, ArbitraryQuadrature *> _holder_qrule_neighbor;
  MooseArray<Real> _current_JxW_neighbor;
  MooseArray<Real> _coord_neighbor;

  /********** mortar stuff *************/

  const std::vector<Real> * _JxW_msm;
  std::unique_ptr<FEBase> _fe_msm;
  QBase * _qrule_msm;
  const QBase * _const_qrule_msm;

  const Elem * _current_elem;
  SubdomainID _current_subdomain_id;
  Real _current_elem_volume;
  unsigned int _current_side;
  const Elem * _current_side_elem;
  Real _current_side_volume;
  const Elem * _current_neighbor_elem;
  SubdomainID _current_neighbor_subdomain_id;
  unsigned int _current_neighbor_side;
  const Elem * _current_neighbor_side_elem;
  mutable bool _need_neighbor_elem_volume;
  Real _current_neighbor_volume;
  const Node * _current_node;
  const Node * _current_neighbor_node;
  bool _current_elem_volume_computed;
  bool _current_side_volume_computed;

  const Elem * _current_lower_d_elem;

  MooseArray<Point> _current_physical_points;

  std::vector<std::vector<DenseVector<Number>>> _sub_Re;
  std::vector<std::vector<DenseVector<Number>>> _sub_Rn;
  std::vector<std::vector<DenseVector<Number>>> _sub_Rl;
  DenseVector<Number> _tmp_Re;

  std::vector<std::vector<std::vector<DenseMatrix<Number>>>> _sub_Kee;
  std::vector<std::vector<std::vector<DenseMatrix<Number>>>> _sub_Keg;

  std::vector<std::vector<std::vector<DenseMatrix<Number>>>> _sub_Ken;
  std::vector<std::vector<std::vector<DenseMatrix<Number>>>> _sub_Kne;
  std::vector<std::vector<std::vector<DenseMatrix<Number>>>> _sub_Knn;
  std::vector<std::vector<std::vector<DenseMatrix<Number>>>> _sub_Kll;
  std::vector<std::vector<std::vector<DenseMatrix<Number>>>> _sub_Kle;
  std::vector<std::vector<std::vector<DenseMatrix<Number>>>> _sub_Kln;
  std::vector<std::vector<std::vector<DenseMatrix<Number>>>> _sub_Kel;
  std::vector<std::vector<std::vector<DenseMatrix<Number>>>> _sub_Knl;

  DenseMatrix<Number> _tmp_Ke;

  // Shape function values, gradients. second derivatives
  VariablePhiValue _phi;
  VariablePhiGradient _grad_phi;
  VariablePhiSecond _second_phi;

  VariablePhiValue _phi_face;
  VariablePhiGradient _grad_phi_face;
  VariablePhiSecond _second_phi_face;

  VariablePhiValue _phi_neighbor;
  VariablePhiGradient _grad_phi_neighbor;
  VariablePhiSecond _second_phi_neighbor;

  VariablePhiValue _phi_face_neighbor;
  VariablePhiGradient _grad_phi_face_neighbor;
  VariablePhiSecond _second_phi_face_neighbor;

  // Shape function values, gradients, second derivatives
  VectorVariablePhiValue _vector_phi;
  VectorVariablePhiGradient _vector_grad_phi;
  VectorVariablePhiSecond _vector_second_phi;
  VectorVariablePhiCurl _vector_curl_phi;

  VectorVariablePhiValue _vector_phi_face;
  VectorVariablePhiGradient _vector_grad_phi_face;
  VectorVariablePhiSecond _vector_second_phi_face;
  VectorVariablePhiCurl _vector_curl_phi_face;

  VectorVariablePhiValue _vector_phi_neighbor;
  VectorVariablePhiGradient _vector_grad_phi_neighbor;
  VectorVariablePhiSecond _vector_second_phi_neighbor;
  VectorVariablePhiCurl _vector_curl_phi_neighbor;

  VectorVariablePhiValue _vector_phi_face_neighbor;
  VectorVariablePhiGradient _vector_grad_phi_face_neighbor;
  VectorVariablePhiSecond _vector_second_phi_face_neighbor;
  VectorVariablePhiCurl _vector_curl_phi_face_neighbor;

  class FEShapeData
  {
  public:
    VariablePhiValue _phi;
    VariablePhiGradient _grad_phi;
    VariablePhiSecond _second_phi;
    VariablePhiCurl _curl_phi;
  };

  class VectorFEShapeData
  {
  public:
    VectorVariablePhiValue _phi;
    VectorVariablePhiGradient _grad_phi;
    VectorVariablePhiSecond _second_phi;
    VectorVariablePhiCurl _curl_phi;
  };

  mutable std::map<FEType, FEShapeData *> _fe_shape_data;
  mutable std::map<FEType, FEShapeData *> _fe_shape_data_face;
  mutable std::map<FEType, FEShapeData *> _fe_shape_data_neighbor;
  mutable std::map<FEType, FEShapeData *> _fe_shape_data_face_neighbor;
  mutable std::map<FEType, FEShapeData *> _fe_shape_data_lower;

  mutable std::map<FEType, VectorFEShapeData *> _vector_fe_shape_data;
  mutable std::map<FEType, VectorFEShapeData *> _vector_fe_shape_data_face;
  mutable std::map<FEType, VectorFEShapeData *> _vector_fe_shape_data_neighbor;
  mutable std::map<FEType, VectorFEShapeData *> _vector_fe_shape_data_face_neighbor;
  mutable std::map<FEType, VectorFEShapeData *> _vector_fe_shape_data_lower;

  mutable std::map<FEType, typename VariableTestGradientType<Real, ComputeStage::JACOBIAN>::type>
      _ad_grad_phi_data;
  mutable std::map<FEType,
                   typename VariableTestGradientType<RealVectorValue, ComputeStage::JACOBIAN>::type>
      _ad_vector_grad_phi_data;
  mutable std::map<FEType, typename VariableTestGradientType<Real, ComputeStage::JACOBIAN>::type>
      _ad_grad_phi_data_face;
  mutable std::map<FEType,
                   typename VariableTestGradientType<RealVectorValue, ComputeStage::JACOBIAN>::type>
      _ad_vector_grad_phi_data_face;

  std::vector<std::vector<Real>> _cached_residual_values;

  std::vector<std::vector<dof_id_type>> _cached_residual_rows;

  unsigned int _max_cached_residuals;

  std::vector<std::vector<Real>> _cached_jacobian_values;
  std::vector<std::vector<dof_id_type>> _cached_jacobian_rows;
  std::vector<std::vector<dof_id_type>> _cached_jacobian_cols;

  unsigned int _max_cached_jacobians;

  unsigned int _block_diagonal_matrix;

  std::vector<dof_id_type> _temp_dof_indices;

  std::vector<Point> _temp_reference_points;

  std::vector<std::vector<Real>> _cached_jacobian_contribution_vals;
  std::vector<std::vector<numeric_index_type>> _cached_jacobian_contribution_rows;
  std::vector<std::vector<numeric_index_type>> _cached_jacobian_contribution_cols;

  std::vector<VectorValue<DualReal>> _ad_dxyzdxi_map;
  std::vector<VectorValue<DualReal>> _ad_dxyzdeta_map;
  std::vector<VectorValue<DualReal>> _ad_dxyzdzeta_map;
  std::vector<VectorValue<DualReal>> _ad_d2xyzdxi2_map;
  std::vector<VectorValue<DualReal>> _ad_d2xyzdxideta_map;
  std::vector<VectorValue<DualReal>> _ad_d2xyzdeta2_map;
  std::vector<DualReal> _ad_jac;
  MooseArray<DualReal> _ad_JxW;
  MooseArray<VectorValue<DualReal>> _ad_q_points;
  std::vector<DualReal> _ad_dxidx_map;
  std::vector<DualReal> _ad_dxidy_map;
  std::vector<DualReal> _ad_dxidz_map;
  std::vector<DualReal> _ad_detadx_map;
  std::vector<DualReal> _ad_detady_map;
  std::vector<DualReal> _ad_detadz_map;
  std::vector<DualReal> _ad_dzetadx_map;
  std::vector<DualReal> _ad_dzetady_map;
  std::vector<DualReal> _ad_dzetadz_map;

  MooseArray<DualReal> _ad_JxW_face;
  MooseArray<VectorValue<DualReal>> _ad_normals;
  MooseArray<VectorValue<DualReal>> _ad_q_points_face;
  MooseArray<Real> _curvatures;
  MooseArray<DualReal> _ad_curvatures;

  std::vector<unsigned> _displacements;

  mutable bool _calculate_xyz;
  mutable bool _calculate_face_xyz;
  mutable bool _calculate_curvatures;

  mutable std::map<FEType, bool> _need_second_derivative;
  mutable std::map<FEType, bool> _need_second_derivative_neighbor;
  mutable std::map<FEType, bool> _need_curl;
};

template <typename OutputType>
const typename OutputTools<OutputType>::VariablePhiValue &
Assembly::fePhiLower(FEType type) const
{
  buildLowerDFE(type);
  return _fe_shape_data_lower[type]->_phi;
}

template <typename OutputType>
const typename OutputTools<OutputType>::VariablePhiGradient &
Assembly::feGradPhiLower(FEType type) const
{
  buildLowerDFE(type);
  return _fe_shape_data_lower[type]->_grad_phi;
}

template <>
inline const typename VariableTestGradientType<RealVectorValue, ComputeStage::JACOBIAN>::type &
Assembly::feADGradPhi<RealVectorValue>(FEType type) const
{
  return _ad_vector_grad_phi_data[type];
}

template <>
inline const typename VariableTestGradientType<RealVectorValue, ComputeStage::JACOBIAN>::type &
Assembly::feADGradPhiFace<RealVectorValue>(FEType type) const
{
  return _ad_vector_grad_phi_data_face[type];
}

template <>
inline void
Assembly::computeGradPhiAD<RealVectorValue>(
    const Elem *,
    unsigned int,
    typename VariableTestGradientType<RealVectorValue, ComputeStage::JACOBIAN>::type &,
    FEGenericBase<RealVectorValue> *)
{
  mooseError("Not implemented");
}

template <>
inline const MooseArray<typename Moose::RealType<ComputeStage::JACOBIAN>::type> &
Assembly::adCurvatures<ComputeStage::JACOBIAN>() const
{
  _calculate_curvatures = true;
  return _ad_curvatures;
}

template <>
inline const MooseArray<VectorValue<DualReal>> &
Assembly::adNormals<ComputeStage::JACOBIAN>() const
{
  return _ad_normals;
}

template <>
inline const typename PointType<ComputeStage::JACOBIAN>::type &
Assembly::adQPoints<ComputeStage::JACOBIAN>() const
{
  _calculate_xyz = true;
  return _ad_q_points;
}

template <>
inline const typename PointType<ComputeStage::JACOBIAN>::type &
Assembly::adQPointsFace<ComputeStage::JACOBIAN>() const
{
  _calculate_face_xyz = true;
  return _ad_q_points_face;
}

template <>
inline const MooseArray<DualReal> &
Assembly::adJxWFace<ComputeStage::JACOBIAN>() const
{
  return _ad_JxW_face;
}

template <>
inline const MooseArray<DualReal> &
Assembly::adCoordTransformation<ComputeStage::JACOBIAN>() const
{
  _calculate_xyz = _calculate_face_xyz = true;
  return _ad_coord;
}

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiValue &
Assembly::fePhi<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiGradient &
Assembly::feGradPhi<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiSecond &
Assembly::feSecondPhi<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiValue &
Assembly::fePhiLower<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiGradient &
Assembly::feGradPhiLower<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiValue &
Assembly::fePhiFace<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiGradient &
Assembly::feGradPhiFace<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiSecond &
Assembly::feSecondPhiFace<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiValue &
Assembly::fePhiNeighbor<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiGradient &
Assembly::feGradPhiNeighbor<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiSecond &
Assembly::feSecondPhiNeighbor<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiValue &
Assembly::fePhiFaceNeighbor<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiGradient &
Assembly::feGradPhiFaceNeighbor<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiSecond &
Assembly::feSecondPhiFaceNeighbor<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiCurl &
Assembly::feCurlPhi<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiCurl &
Assembly::feCurlPhiFace<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiCurl &
Assembly::feCurlPhiNeighbor<VectorValue<Real>>(FEType type) const;

template <>
const typename OutputTools<VectorValue<Real>>::VariablePhiCurl &
Assembly::feCurlPhiFaceNeighbor<VectorValue<Real>>(FEType type) const;

template <>
const typename VariableTestGradientType<Real, ComputeStage::JACOBIAN>::type &
Assembly::adGradPhi<Real, ComputeStage::JACOBIAN>(const MooseVariableFE<Real> & v) const;

template <>
const typename VariableTestGradientType<RealVectorValue, ComputeStage::JACOBIAN>::type &
Assembly::adGradPhi<RealVectorValue, ComputeStage::JACOBIAN>(
    const MooseVariableFE<RealVectorValue> & v) const;

template <>
const MooseArray<typename Moose::RealType<RESIDUAL>::type> & Assembly::adJxW<RESIDUAL>() const;