MooseVariableDataBase.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 "libmesh/tensor_tools.h"
#include "libmesh/vector_value.h"
#include "libmesh/tensor_value.h"
#include "libmesh/type_n_tensor.h"
#include "libmesh/enum_fe_family.h"
 
#include <vector>
 
template <typename>
class MooseVariableField;
class SubProblem;
class SystemBase;
namespace libMesh
{
class DofMap;
}
 
template <typename OutputType>
class MooseVariableDataBase
{
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;
 
  // DoF value type for the template class OutputType
  typedef typename Moose::DOFType<OutputType>::type DofValue;
  typedef typename Moose::ADType<DofValue>::type ADDofValue;
  typedef MooseArray<DofValue> DofValues;
  typedef MooseArray<ADDofValue> ADDofValues;
 
  MooseVariableDataBase(const MooseVariableField<OutputType> & var,
                        SystemBase & sys,
                        THREAD_ID tid);
 
  virtual ~MooseVariableDataBase() = default;
 
  virtual bool isNodal() const = 0;
 
  virtual bool hasDoFsOnNodes() const = 0;
 
  virtual libMesh::FEContinuity getContinuity() const = 0;
 
  const FieldVariableValue & sln(Moose::SolutionState state) const;
 
  const FieldVariableGradient & gradSln(Moose::SolutionState state) const;
 
  unsigned int oldestSolutionStateRequested() const;
 
  void setNodalValue(const OutputType & value, unsigned int idx = 0);
 
  void insert(libMesh::NumericVector<libMesh::Number> & residual);
 
  void add(libMesh::NumericVector<libMesh::Number> & residual);
 
  void prepareIC();
 
 
  const DofValues & dofValues() const;
  const DofValues & dofValuesOld() const;
  const DofValues & dofValuesOlder() const;
  const DofValues & dofValuesPreviousNL() const;
 
 
  const OutputType & nodalValue(Moose::SolutionState state) const;
  const MooseArray<OutputType> & nodalValueArray(Moose::SolutionState state) const;
 
 
  const FieldVariableValue & vectorTagValue(TagID tag) const;
  const FieldVariableGradient & vectorTagGradient(TagID tag) const;
  const FieldVariableValue & matrixTagValue(TagID tag) const;
  const DofValues & nodalVectorTagValue(TagID tag) const;
  const DofValues & nodalMatrixTagValue(TagID tag) const;
  const DofValues & vectorTagDofValue(TagID tag) const;
  const DofValues & vectorTagDofValue(Moose::SolutionState state) const;
 
  void setActiveTags(const std::set<TagID> & vtags);
 
  void prepareAux() { _has_dof_values = false; }
 
  void sizeMatrixTagData();
 
protected:
  virtual const MooseVariableField<OutputType> & var() const { return _var; }
 
  void insertSolutionTag(TagID tag_id);
 
  void needSolutionState(unsigned int state);
 
  void fetchDofValues();
  void zeroSizeDofValues();
  void getArrayDofValues(const libMesh::NumericVector<libMesh::Number> & sol,
                         unsigned int n,
                         MooseArray<RealEigenVector> & dof_values) const;
  void assignNodalValue();
 
  template <typename ReturnType, typename Functor>
  const ReturnType & stateToTagHelper(Moose::SolutionState state, Functor functor);
 
  void resizeVectorTagData(TagID tag);
 
  SystemBase & _sys;
 
  const SubProblem & _subproblem;
 
  const THREAD_ID _tid;
 
  const libMesh::DofMap & _dof_map;
 
  unsigned int _count;
 
  bool _has_dof_values;
 
  unsigned int _max_state;
 
  TagID _solution_tag;
 
  TagID _old_solution_tag;
 
  TagID _older_solution_tag;
 
  TagID _previous_nl_solution_tag;
 
  std::vector<dof_id_type> _dof_indices;
 
  mutable std::vector<bool> _need_vector_tag_dof_u;
  mutable std::vector<bool> _need_matrix_tag_dof_u;
 
  // Dof values of tagged vectors
  std::vector<DofValues> _vector_tags_dof_u;
  // Dof values of the diagonal of tagged matrices
  std::vector<DofValues> _matrix_tags_dof_u;
 
  std::vector<FieldVariableValue> _vector_tag_u;
  mutable std::vector<bool> _need_vector_tag_u;
  std::vector<FieldVariableGradient> _vector_tag_grad;
  mutable std::vector<bool> _need_vector_tag_grad;
  std::vector<FieldVariableValue> _matrix_tag_u;
  mutable std::vector<bool> _need_matrix_tag_u;
 
  OutputType _nodal_value;
  OutputType _nodal_value_old;
  OutputType _nodal_value_older;
  OutputType _nodal_value_previous_nl;
 
  MooseArray<OutputType> _nodal_value_array;
  MooseArray<OutputType> _nodal_value_old_array;
  MooseArray<OutputType> _nodal_value_older_array;
 
  mutable bool _need_u_dot;
  mutable bool _need_u_dotdot;
  mutable bool _need_u_dot_old;
  mutable bool _need_u_dotdot_old;
  mutable bool _need_du_dot_du;
  mutable bool _need_du_dotdot_du;
 
  mutable bool _need_grad_dot;
  mutable bool _need_grad_dotdot;
 
  mutable bool _need_dof_values_dot;
  mutable bool _need_dof_values_dotdot;
  mutable bool _need_dof_values_dot_old;
  mutable bool _need_dof_values_dotdot_old;
  mutable bool _need_dof_du_dot_du;
  mutable bool _need_dof_du_dotdot_du;
 
  DofValues _dof_values_dot;
  DofValues _dof_values_dotdot;
  DofValues _dof_values_dot_old;
  DofValues _dof_values_dotdot_old;
  MooseArray<libMesh::Number> _dof_du_dot_du;
  MooseArray<libMesh::Number> _dof_du_dotdot_du;
 
  OutputType _nodal_value_dot;
  OutputType _nodal_value_dotdot;
  OutputType _nodal_value_dot_old;
  OutputType _nodal_value_dotdot_old;
 
  std::set<TagID> _required_vector_tags;
 
  std::set<TagID> _solution_tags;
 
private:
  const MooseVariableField<OutputType> & _var;
};
 
template <>
void MooseVariableDataBase<RealEigenVector>::fetchDofValues();
 
template <>
void MooseVariableDataBase<RealVectorValue>::assignNodalValue();
 
template <typename OutputType>
void
MooseVariableDataBase<OutputType>::setActiveTags(const std::set<TagID> & vtags)
{
  _required_vector_tags = _solution_tags;
  for (const auto tag : vtags)
    _required_vector_tags.insert(tag);
 
  if (!_required_vector_tags.empty())
  {
    const auto largest_tag_id = *_required_vector_tags.rbegin();
    if (largest_tag_id >= _need_vector_tag_dof_u.size())
      resizeVectorTagData(largest_tag_id);
  }
}
 
template <typename OutputType>
void
MooseVariableDataBase<OutputType>::insertSolutionTag(const TagID tag_id)
{
  _solution_tags.insert(tag_id);
  _required_vector_tags.insert(tag_id);
}