MooseVariableField.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 "MooseVariableFieldBase.h"
#include "SubProblem.h"
#include "MooseMesh.h"
#include "MooseVariableData.h"
#include "MooseFunctor.h"
#include "MeshChangedInterface.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/dense_vector.h"

template <typename OutputType>
class MooseVariableField : public MooseVariableFieldBase,
                           public Moose::FunctorBase<typename Moose::ADType<OutputType>::type>,
                           public MeshChangedInterface
{
public:
  // type for gradient, second and divergence of template class OutputType
  typedef typename libMesh::TensorTools::IncrementRank<OutputType>::type OutputGradient;
  typedef typename libMesh::TensorTools::IncrementRank<OutputGradient>::type OutputSecond;
  typedef typename libMesh::TensorTools::DecrementRank<OutputType>::type OutputDivergence;

  // shortcut for types storing values on quadrature points
  typedef MooseArray<OutputType> FieldVariableValue;
  typedef MooseArray<OutputGradient> FieldVariableGradient;
  typedef MooseArray<OutputSecond> FieldVariableSecond;
  typedef MooseArray<OutputType> FieldVariableCurl;
  typedef MooseArray<OutputDivergence> FieldVariableDivergence;

  // shape function type for the template class OutputType
  typedef typename Moose::ShapeType<OutputType>::type OutputShape;

  // type for gradient, second and divergence of shape functions of template class OutputType
  typedef typename libMesh::TensorTools::IncrementRank<OutputShape>::type OutputShapeGradient;
  typedef typename libMesh::TensorTools::IncrementRank<OutputShapeGradient>::type OutputShapeSecond;
  typedef typename libMesh::TensorTools::DecrementRank<OutputShape>::type OutputShapeDivergence;

  // shortcut for types storing shape function values on quadrature points
  typedef MooseArray<std::vector<OutputShape>> FieldVariablePhiValue;
  typedef MooseArray<std::vector<OutputShapeGradient>> FieldVariablePhiGradient;
  typedef MooseArray<std::vector<OutputShapeSecond>> FieldVariablePhiSecond;
  typedef MooseArray<std::vector<OutputShape>> FieldVariablePhiCurl;
  typedef MooseArray<std::vector<OutputShapeDivergence>> FieldVariablePhiDivergence;

  // shortcut for types storing test function values on quadrature points
  // Note: here we assume the types are the same as of shape functions.
  typedef MooseArray<std::vector<OutputShape>> FieldVariableTestValue;
  typedef MooseArray<std::vector<OutputShapeGradient>> FieldVariableTestGradient;
  typedef MooseArray<std::vector<OutputShapeSecond>> FieldVariableTestSecond;
  typedef MooseArray<std::vector<OutputShape>> FieldVariableTestCurl;
  typedef MooseArray<std::vector<OutputShapeDivergence>> FieldVariableTestDivergence;

  // DoF value type for the template class OutputType
  using DofValue = typename MooseVariableDataBase<OutputType>::DofValue;
  using DofValues = typename MooseVariableDataBase<OutputType>::DofValues;
  using ADDofValue = typename MooseVariableDataBase<OutputType>::ADDofValue;
  using ADDofValues = typename MooseVariableDataBase<OutputType>::ADDofValues;

  MooseVariableField(const InputParameters & parameters);

  virtual Moose::VarFieldType fieldType() const override;
  virtual bool isArray() const override;
  virtual bool isVector() const override;

  static InputParameters validParams();

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


  virtual void setDofValue(const DofValue & value, unsigned int index) = 0;

  virtual const ADTemplateVariableValue<OutputType> & adSln() const = 0;

  virtual const ADTemplateVariableValue<OutputType> & adSlnNeighbor() const = 0;

  virtual const ADTemplateVariableGradient<OutputType> & adGradSln() const = 0;

  virtual const ADTemplateVariableGradient<OutputType> & adGradSlnDot() const = 0;

  virtual const ADTemplateVariableCurl<OutputType> & adCurlSln() const = 0;

  virtual const ADTemplateVariableGradient<OutputType> & adGradSlnNeighbor() const = 0;

  virtual const ADTemplateVariableGradient<OutputType> & adGradSlnNeighborDot() const = 0;

  virtual const ADTemplateVariableCurl<OutputType> & adCurlSlnNeighbor() const = 0;

  virtual const ADTemplateVariableSecond<OutputType> & adSecondSln() const = 0;

  virtual const ADTemplateVariableSecond<OutputType> & adSecondSlnNeighbor() const = 0;

  virtual const ADTemplateVariableValue<OutputType> & adUDot() const = 0;

  virtual const ADTemplateVariableValue<OutputType> & adUDotDot() const = 0;

  virtual const ADTemplateVariableValue<OutputType> & adUDotNeighbor() const = 0;

  virtual const ADTemplateVariableValue<OutputType> & adUDotDotNeighbor() const = 0;

  virtual const ADDofValues & adDofValues() const = 0;

  virtual const ADDofValues & adDofValuesNeighbor() const = 0;

  virtual const ADDofValues & adDofValuesDot() const = 0;


  virtual const MooseArray<OutputType> & nodalValueArray() const = 0;
  virtual const MooseArray<OutputType> & nodalValueOldArray() const = 0;
  virtual const MooseArray<OutputType> & nodalValueOlderArray() const = 0;

  virtual const FieldVariableValue & sln() const = 0;

  virtual const FieldVariableValue & slnOld() const = 0;

  virtual const FieldVariableValue & slnNeighbor() const = 0;

  virtual const FieldVariableValue & slnOldNeighbor() const = 0;

  virtual const FieldVariableValue & slnOlder() const = 0;

  virtual const FieldVariableGradient & gradSln() const = 0;
  virtual const FieldVariableGradient & gradSlnOld() const = 0;

  virtual const FieldVariableGradient & gradSlnNeighbor() const = 0;
  virtual const FieldVariableGradient & gradSlnOldNeighbor() const = 0;

  virtual bool computingSecond() const = 0;

  virtual bool computingCurl() const = 0;

  virtual bool computingDiv() const = 0;

  virtual const FieldVariablePhiValue & phi() const = 0;

  virtual const FieldVariablePhiGradient & gradPhi() const = 0;

  virtual const FieldVariablePhiSecond & secondPhi() const = 0;

  virtual const FieldVariablePhiValue & curlPhi() const = 0;

  virtual const FieldVariablePhiDivergence & divPhi() const = 0;

  virtual const FieldVariablePhiValue & phiFace() const = 0;

  virtual const FieldVariablePhiGradient & gradPhiFace() const = 0;

  virtual const FieldVariablePhiSecond & secondPhiFace() const = 0;

  virtual const FieldVariablePhiValue & phiFaceNeighbor() const = 0;

  virtual const FieldVariablePhiGradient & gradPhiFaceNeighbor() const = 0;

  virtual const FieldVariablePhiSecond & secondPhiFaceNeighbor() const = 0;

  virtual const FieldVariablePhiValue & phiNeighbor() const = 0;

  virtual const FieldVariablePhiGradient & gradPhiNeighbor() const = 0;

  virtual const FieldVariablePhiSecond & secondPhiNeighbor() const = 0;

  virtual const FieldVariablePhiValue & phiLower() const = 0;

  virtual void setDofValues(const DenseVector<DofValue> & values) = 0;

  virtual void setLowerDofValues(const DenseVector<DofValue> & values) = 0;

  bool usesPhiNeighbor() const { return true; }

  bool usesGradPhiNeighbor() const { return true; }

  virtual bool usesSecondPhiNeighbor() const = 0;


  virtual const DofValues & dofValues() const = 0;
  virtual const DofValues & dofValuesOld() const = 0;
  virtual const DofValues & dofValuesOlder() const = 0;
  virtual const DofValues & dofValuesPreviousNL() const = 0;
  virtual const DofValues & dofValuesNeighbor() const = 0;
  virtual const DofValues & dofValuesOldNeighbor() const = 0;
  virtual const DofValues & dofValuesOlderNeighbor() const = 0;
  virtual const DofValues & dofValuesPreviousNLNeighbor() const = 0;
  virtual const DofValues & dofValuesDot() const = 0;
  virtual const DofValues & dofValuesDotNeighbor() const = 0;
  virtual const DofValues & dofValuesDotOld() const = 0;
  virtual const DofValues & dofValuesDotOldNeighbor() const = 0;
  virtual const DofValues & dofValuesDotDot() const = 0;
  virtual const DofValues & dofValuesDotDotNeighbor() const = 0;
  virtual const DofValues & dofValuesDotDotOld() const = 0;
  virtual const DofValues & dofValuesDotDotOldNeighbor() const = 0;
  virtual const MooseArray<libMesh::Number> & dofValuesDuDotDu() const = 0;
  virtual const MooseArray<libMesh::Number> & dofValuesDuDotDuNeighbor() const = 0;
  virtual const MooseArray<libMesh::Number> & dofValuesDuDotDotDu() const = 0;
  virtual const MooseArray<libMesh::Number> & dofValuesDuDotDotDuNeighbor() const = 0;

  template <bool is_ad>
  const MooseArray<GenericReal<is_ad>> & genericDofValues() const;

  virtual const FieldVariableValue & vectorTagValue(TagID tag) const = 0;
  virtual const DofValues & nodalVectorTagValue(TagID tag) const = 0;
  virtual const DofValues & vectorTagDofValue(TagID tag) const = 0;
  virtual const DofValues & nodalMatrixTagValue(TagID tag) const = 0;
  virtual const FieldVariableValue & matrixTagValue(TagID tag) const = 0;

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

  using MooseVariableFieldBase::hasBlocks;
  /*
   * Returns whether a variable is defined on a block as a functor.
   * This makes the link between functor block restriction and the
   * BlockRestrictable interface.
   * @param id subdomain id we want to know whether the variable is defined on
   * @return whether the variable is defined on this domain
   */
  bool hasBlocks(const SubdomainID id) const override { return BlockRestrictable::hasBlocks(id); }

protected:
  const TimeIntegrator * const _time_integrator;

  mutable ADReal _ad_real_dummy = 0;
};

template <>
template <>
const MooseArray<Real> & MooseVariableField<Real>::genericDofValues<false>() const;
template <>
template <>
const MooseArray<Real> & MooseVariableField<RealVectorValue>::genericDofValues<false>() const;
template <>
template <>
const MooseArray<Real> & MooseVariableField<RealEigenVector>::genericDofValues<false>() const;

template <typename OutputType>
template <bool is_ad>
const MooseArray<GenericReal<is_ad>> &
MooseVariableField<OutputType>::genericDofValues() const
{
  return adDofValues();
}

#define usingMooseVariableFieldMembers                                                             \
  usingMooseVariableFieldBaseMembers;                                                              \
  using MooseVariableField<OutputType>::_time_integrator;                                          \
  using MooseVariableField<OutputType>::_ad_real_dummy;                                            \
  using MooseVariableField<OutputType>::getSolution

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