MooseVariableDataFV.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 "MooseArray.h"
#include "MooseTypes.h"
#include "MeshChangedInterface.h"
#include "MooseVariableDataBase.h"
#include "TheWarehouse.h"
 
#include "libmesh/tensor_tools.h"
#include "libmesh/vector_value.h"
#include "libmesh/tensor_value.h"
#include "libmesh/type_n_tensor.h"
#include "libmesh/fe_type.h"
#include "libmesh/dof_map.h"
#include "libmesh/enum_fe_family.h"
#include "SubProblem.h"
 
#include <functional>
#include <vector>
 
class FaceInfo;
class SystemBase;
class TimeIntegrator;
class Assembly;
 
template <typename>
class MooseVariableFV;
 
namespace libMesh
{
class QBase;
}
 
namespace Moose
{
template <typename T>
void
initDofIndices(T & data, const Elem & elem)
{
  if (data._prev_elem != &elem)
  {
    data._dof_map.dof_indices(&elem, data._dof_indices, data._var_num);
    data._prev_elem = &elem;
  }
}
}
 
namespace
{
template <typename T, typename T2>
void
assignForAllQps(const T & value, T2 & array, const unsigned int nqp)
{
  for (const auto qp : make_range(nqp))
    array[qp] = value;
}
}
 
template <typename OutputType>
class MooseVariableDataFV : public MooseVariableDataBase<OutputType>, 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;
 
  // DoF value type for the template class OutputType
  typedef typename Moose::DOFType<OutputType>::type OutputData;
  typedef MooseArray<OutputData> DofValue;
 
  MooseVariableDataFV(const MooseVariableFV<OutputType> & var,
                      SystemBase & sys,
                      THREAD_ID tid,
                      Moose::ElementType element_type,
                      const Elem * const & elem);
 
  bool isNodal() const override { return false; }
  bool hasDoFsOnNodes() const override { return false; }
  libMesh::FEContinuity getContinuity() const override { return libMesh::DISCONTINUOUS; }
 
  bool needsAD() const { return _need_ad; }
 
  void setGeometry(Moose::GeometryType gm_type);
 
 
  void computeValuesFace(const FaceInfo & fi);
 
  void computeValues();
 
  void computeAD(const unsigned int num_dofs, const unsigned int nqp);
 
 
  const Elem * const & currentElem() const { return _elem; }
 
  void prepareIC();
 
 
  const FieldVariableValue & sln(Moose::SolutionState state) const;
 
  const FieldVariableGradient & gradSlnDot() const;
 
  const FieldVariableGradient & gradSlnDotDot() const;
 
  const FieldVariableSecond & secondSln(Moose::SolutionState state) const;
 
  const FieldVariableCurl & curlSln(Moose::SolutionState state) const;
 
  const ADTemplateVariableValue<OutputType> & adSln() const;
 
  const ADTemplateVariableGradient<OutputType> & adGradSln() const;
 
  const ADTemplateVariableGradient<OutputType> & adGradSlnDot() const
  {
    mooseError("Gradient of time derivative not yet implemented for FV");
  }
 
  const ADTemplateVariableSecond<OutputType> & adSecondSln() const;
 
  const ADTemplateVariableValue<OutputType> & adUDot() const;
 
  const ADTemplateVariableValue<OutputType> & adUDotDot() const;
 
  const FieldVariableValue & uDot() const;
 
  const FieldVariableValue & uDotDot() const;
 
  const FieldVariableValue & uDotOld() const;
 
  const FieldVariableValue & uDotDotOld() const;
 
  const VariableValue & duDotDu() const
  {
    _need_du_dot_du = true;
    return _du_dot_du;
  }
 
  const VariableValue & duDotDotDu() const
  {
    _need_du_dotdot_du = true;
    return _du_dotdot_du;
  }
 
  void setDofValues(const DenseVector<OutputData> & values);
 
 
  void setDofValue(const OutputData & value, unsigned int index);
 
  OutputData
  getElementalValue(const Elem * elem, Moose::SolutionState state, unsigned int idx = 0) const;
 
 
  void getDofIndices(const Elem * elem, std::vector<dof_id_type> & dof_indices) const;
  const std::vector<dof_id_type> & dofIndices() const;
  unsigned int numberOfDofs() const;
  void clearDofIndices()
  {
    _dof_indices.clear();
    _prev_elem = nullptr;
  }
 
 
  const DofValue & dofValuesDot() const;
  const DofValue & dofValuesDotOld() const;
  const DofValue & dofValuesDotDot() const;
  const DofValue & dofValuesDotDotOld() const;
  const MooseArray<libMesh::Number> & dofValuesDuDotDu() const;
  const MooseArray<libMesh::Number> & dofValuesDuDotDotDu() const;
 
  const MooseArray<ADReal> & adDofValues() const;
 
  const MooseArray<ADReal> & adDofValuesDot() const;
 
 
  const FieldVariableValue & increment() const { return _increment; }
 
  void computeIncrementAtQps(const libMesh::NumericVector<libMesh::Number> & increment_vec);
 
  bool hasDirichletBC() const { return _has_dirichlet_bc; }
 
  void meshChanged() override;
 
protected:
  virtual const MooseVariableFV<OutputType> & var() const override { return _var; }
 
private:
  void initializeSolnVars();
 
  void fetchADDofValues();
 
  bool safeToComputeADUDot() const;
 
  const MooseVariableFV<OutputType> & _var;
 
  const libMesh::FEType & _fe_type;
 
  const unsigned int _var_num;
 
  const Assembly & _assembly;
 
  Moose::ElementType _element_type;
 
  libMesh::FEContinuity _continuity;
 
  FieldVariableValue _increment;
 
  const ADReal _ad_zero;
 
  mutable bool _need_second;
  mutable bool _need_second_old;
  mutable bool _need_second_older;
  mutable bool _need_second_previous_nl;
 
  mutable bool _need_curl;
  mutable bool _need_curl_old;
  mutable bool _need_curl_older;
 
  mutable bool _need_ad;
  mutable bool _need_ad_u;
  mutable bool _need_ad_u_dot;
  mutable bool _need_ad_u_dotdot;
  mutable bool _need_ad_grad_u;
  mutable bool _need_ad_grad_u_dot;
  mutable bool _need_ad_second_u;
 
  FieldVariableGradient _grad_u_dot;
  FieldVariableGradient _grad_u_dotdot;
 
  FieldVariableSecond _second_u;
  FieldVariableSecond _second_u_old;
  FieldVariableSecond _second_u_older;
  FieldVariableSecond _second_u_previous_nl;
 
  FieldVariableCurl _curl_u;
  FieldVariableCurl _curl_u_old;
  FieldVariableCurl _curl_u_older;
 
  ADTemplateVariableValue<OutputShape> _ad_u;
  ADTemplateVariableGradient<OutputShape> _ad_grad_u;
  ADTemplateVariableSecond<OutputShape> _ad_second_u;
  MooseArray<ADReal> _ad_dof_values;
  MooseArray<ADReal> _ad_dofs_dot;
  MooseArray<ADReal> _ad_dofs_dotdot;
  ADTemplateVariableValue<OutputShape> _ad_u_dot;
  ADTemplateVariableValue<OutputShape> _ad_u_dotdot;
  ADTemplateVariableGradient<OutputShape> _ad_grad_u_dot;
 
  // time derivatives
 
  FieldVariableValue _u_dot;
 
  FieldVariableValue _u_dotdot;
 
  FieldVariableValue _u_dot_old;
 
  FieldVariableValue _u_dotdot_old;
 
  VariableValue _du_dot_du;
 
  VariableValue _du_dotdot_du;
 
  const TimeIntegrator * const _time_integrator;
 
  const Elem * const & _elem;
  mutable const Elem * _prev_elem = nullptr;
 
  const std::vector<dof_id_type> & initDofIndices();
 
  bool _has_dirichlet_bc;
 
  const bool _displaced;
 
  const libMesh::QBase * _qrule;
 
  ADReal _ad_real_dummy = 0;
 
  TheWarehouse::QueryCache<> _fv_elemental_kernel_query_cache;
  TheWarehouse::QueryCache<> _fv_flux_kernel_query_cache;
 
  using MooseVariableDataBase<OutputType>::_sys;
  using MooseVariableDataBase<OutputType>::_subproblem;
  using MooseVariableDataBase<OutputType>::_need_vector_tag_dof_u;
  using MooseVariableDataBase<OutputType>::_need_matrix_tag_dof_u;
  using MooseVariableDataBase<OutputType>::_vector_tags_dof_u;
  using MooseVariableDataBase<OutputType>::_matrix_tags_dof_u;
  using MooseVariableDataBase<OutputType>::_vector_tag_u;
  using MooseVariableDataBase<OutputType>::_need_vector_tag_u;
  using MooseVariableDataBase<OutputType>::_vector_tag_grad;
  using MooseVariableDataBase<OutputType>::_need_vector_tag_grad;
  using MooseVariableDataBase<OutputType>::_matrix_tag_u;
  using MooseVariableDataBase<OutputType>::_need_matrix_tag_u;
  using MooseVariableDataBase<OutputType>::_dof_indices;
  using MooseVariableDataBase<OutputType>::_has_dof_values;
  using MooseVariableDataBase<OutputType>::fetchDofValues;
  using MooseVariableDataBase<OutputType>::assignNodalValue;
  using MooseVariableDataBase<OutputType>::zeroSizeDofValues;
  using MooseVariableDataBase<OutputType>::_solution_tag;
  using MooseVariableDataBase<OutputType>::_old_solution_tag;
  using MooseVariableDataBase<OutputType>::_older_solution_tag;
  using MooseVariableDataBase<OutputType>::_previous_nl_solution_tag;
  using MooseVariableDataBase<OutputType>::_dof_map;
  using MooseVariableDataBase<OutputType>::_need_u_dot;
  using MooseVariableDataBase<OutputType>::_need_u_dotdot;
  using MooseVariableDataBase<OutputType>::_need_u_dot_old;
  using MooseVariableDataBase<OutputType>::_need_u_dotdot_old;
  using MooseVariableDataBase<OutputType>::_need_du_dot_du;
  using MooseVariableDataBase<OutputType>::_need_du_dotdot_du;
  using MooseVariableDataBase<OutputType>::_need_grad_dot;
  using MooseVariableDataBase<OutputType>::_need_grad_dotdot;
  using MooseVariableDataBase<OutputType>::_need_dof_values_dot;
  using MooseVariableDataBase<OutputType>::_need_dof_values_dotdot;
  using MooseVariableDataBase<OutputType>::_need_dof_values_dot_old;
  using MooseVariableDataBase<OutputType>::_need_dof_values_dotdot_old;
  using MooseVariableDataBase<OutputType>::_need_dof_du_dot_du;
  using MooseVariableDataBase<OutputType>::_need_dof_du_dotdot_du;
  using MooseVariableDataBase<OutputType>::_dof_values_dot;
  using MooseVariableDataBase<OutputType>::_dof_values_dotdot;
  using MooseVariableDataBase<OutputType>::_dof_values_dot_old;
  using MooseVariableDataBase<OutputType>::_dof_values_dotdot_old;
  using MooseVariableDataBase<OutputType>::_dof_du_dot_du;
  using MooseVariableDataBase<OutputType>::_dof_du_dotdot_du;
  using MooseVariableDataBase<OutputType>::_tid;
  using MooseVariableDataBase<OutputType>::_nodal_value_dot;
  using MooseVariableDataBase<OutputType>::_nodal_value_dotdot;
  using MooseVariableDataBase<OutputType>::_nodal_value_dot_old;
  using MooseVariableDataBase<OutputType>::_nodal_value_dotdot_old;
  using MooseVariableDataBase<OutputType>::_required_vector_tags;
 
  friend void Moose::initDofIndices<>(MooseVariableDataFV<OutputType> &, const Elem &);
};
 
 
template <typename OutputType>
inline bool
MooseVariableDataFV<OutputType>::safeToComputeADUDot() const
{
  // If we don't have a time integrator then we have no way to calculate _ad_u_dot because we rely
  // on calls to TimeIntegrator::computeADTimeDerivatives. Another potential situation where
  // _ad_u_dot computation is potentially troublesome is if we are an auxiliary variable which uses
  // the auxiliary system copy of the time integrator. Some derived time integrator classes do setup
  // in their solve() method, and that solve() method only happens for the nonlinear system copy of
  // the time integrator.
  return _time_integrator && (_var.kind() == Moose::VAR_SOLVER);
}
 
template <typename OutputType>
const ADTemplateVariableValue<OutputType> &
MooseVariableDataFV<OutputType>::adUDotDot() const
{
  // Generally speaking, we need u dot information when computing u dot dot
  adUDot();
 
  _need_ad = _need_ad_u_dotdot = true;
 
  if (!safeToComputeADUDot())
    // We will just copy the value of _u_dotdot into _ad_u_dotdot
    _need_u_dotdot = true;
 
  return _ad_u_dotdot;
}
 
template <typename OutputType>
const std::vector<dof_id_type> &
MooseVariableDataFV<OutputType>::dofIndices() const
{
  return const_cast<MooseVariableDataFV<OutputType> *>(this)->initDofIndices();
}
 
template <typename OutputType>
unsigned int
MooseVariableDataFV<OutputType>::numberOfDofs() const
{
  return dofIndices().size();
}