MooseVariableDataLinearFV.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 "MooseVariableDataFV.h"
 
#include <functional>
#include <vector>
 
class FaceInfo;
class SystemBase;
class TimeIntegrator;
class Assembly;
 
template <typename>
class MooseVariableFV;
 
namespace libMesh
{
class QBase;
}
 
template <typename OutputType>
class MooseVariableDataLinearFV : public MooseVariableDataBase<OutputType>
{
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;
 
  using typename MooseVariableDataBase<OutputType>::DofValue;
  using typename MooseVariableDataBase<OutputType>::DofValues;
 
  MooseVariableDataLinearFV(const MooseLinearVariableFV<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; }
 
  void setGeometry(Moose::GeometryType gm_type);
 
  void computeValues();
 
  void prepareIC();
 
  void setDofValues(const DenseVector<DofValue> & values);
 
  void setDofValue(const DofValue & value, unsigned int index);
 
  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;
  }
 
protected:
  virtual const MooseLinearVariableFV<OutputType> & var() const override;
 
private:
  void initializeSolnVars();
 
  const MooseLinearVariableFV<OutputType> & _var;
 
  const libMesh::FEType & _fe_type;
 
  const unsigned int _var_num;
 
  const Assembly & _assembly;
 
  Moose::ElementType _element_type;
 
  const TimeIntegrator * const _time_integrator;
 
  const Elem * const & _elem;
 
  mutable const Elem * _prev_elem = nullptr;
 
  const std::vector<dof_id_type> & initDofIndices();
 
  const bool _displaced;
 
  const libMesh::QBase * _qrule;
 
  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<>(MooseVariableDataLinearFV<OutputType> &, const Elem &);
};
 
 
template <typename OutputType>
const std::vector<dof_id_type> &
MooseVariableDataLinearFV<OutputType>::dofIndices() const
{
  return const_cast<MooseVariableDataLinearFV<OutputType> *>(this)->initDofIndices();
}
 
template <typename OutputType>
unsigned int
MooseVariableDataLinearFV<OutputType>::numberOfDofs() const
{
  return dofIndices().size();
}