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 OutputData;
  typedef MooseArray<OutputData> DoFValue;

  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 DoFValue & dofValues() const;
  const DoFValue & dofValuesOld() const;
  const DoFValue & dofValuesOlder() const;
  const DoFValue & 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 DoFValue & nodalVectorTagValue(TagID tag) const;
  const DoFValue & nodalMatrixTagValue(TagID tag) const;
  const DoFValue & vectorTagDofValue(TagID tag) const;
  const DoFValue & 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<DoFValue> _vector_tags_dof_u;
  // Dof values of the diagonal of tagged matrices
  std::vector<DoFValue> _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;

  DoFValue _dof_values_dot;
  DoFValue _dof_values_dotdot;
  DoFValue _dof_values_dot_old;
  DoFValue _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);
}