MooseVariableScalar.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 "MooseVariableBase.h"
#include "MooseFunctor.h"
#include "SystemBase.h"
 
// libMesh forward declarations
namespace libMesh
{
template <typename T>
class NumericVector;
}
 
class Assembly;
class TimeIntegrator;
 
class MooseVariableScalar : public MooseVariableBase, public Moose::FunctorBase<ADReal>
{
public:
  static InputParameters validParams();
 
  MooseVariableScalar(const InputParameters & parameters);
  virtual ~MooseVariableScalar();
 
  bool supportsQpBasedLoops() const override { return false; }
  bool supportsGeometricInfoBasedLoops() const override { return false; }
 
  void reinit(bool reinit_for_derivative_reordering = false);
 
  const VariableValue & sln() const { return _u; }
 
  const ADVariableValue & adSln() const;
 
  const VariableValue & slnOld() const;
  const VariableValue & slnOlder() const;
  const VariableValue & vectorTagSln(TagID tag) const;
  const VariableValue & matrixTagSln(TagID tag) const;
 
  const VariableValue & uDot() const;
  const VariableValue & uDotDot() const;
  const VariableValue & uDotOld() const;
  const VariableValue & uDotDotOld() const;
  const VariableValue & duDotDu() const;
  const VariableValue & duDotDotDu() const;
 
  const ADVariableValue & adUDot() const;
 
  void setValue(unsigned int i, Number value);
 
  void setValues(Number value);
 
  void insert(NumericVector<Number> & soln);
 
  unsigned int oldestSolutionStateRequested() const;
 
  void setActiveTags(const std::set<TagID> & vtags) override { _required_vector_tags = vtags; }
 
  virtual void sizeMatrixTagData() override;
 
  bool supportsFaceArg() const override final { return true; }
  bool supportsElemSideQpArg() const override final { return true; }
 
protected:
  VariableValue _u;
  VariableValue _u_old;
  VariableValue _u_older;
  std::vector<VariableValue> _vector_tag_u;
  mutable std::vector<bool> _need_vector_tag_u;
  std::vector<VariableValue> _matrix_tag_u;
  mutable std::vector<bool> _need_matrix_tag_u;
 
  VariableValue _u_dot;
  VariableValue _u_dotdot;
  VariableValue _u_dot_old;
  VariableValue _u_dotdot_old;
  VariableValue _du_dot_du;
  VariableValue _du_dotdot_du;
 
  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_u_old;
  mutable bool _need_u_older;
 
  mutable bool _need_ad;
  mutable bool _need_ad_u;
  mutable bool _need_ad_u_dot;
  ADVariableValue _ad_u;
  ADVariableValue _ad_u_dot;
 
private:
  using typename Moose::FunctorBase<ADReal>::ValueType;
  using typename Moose::FunctorBase<ADReal>::GradientType;
  using typename Moose::FunctorBase<ADReal>::DotType;
 
  using ElemArg = Moose::ElemArg;
  using ElemQpArg = Moose::ElemQpArg;
  using ElemSideQpArg = Moose::ElemSideQpArg;
  using FaceArg = Moose::FaceArg;
  using ElemPointArg = Moose::ElemPointArg;
  using NodeArg = Moose::NodeArg;
 
  ValueType evaluate(const ElemArg & elem, const Moose::StateArg & state) const override final;
  ValueType evaluate(const FaceArg & face, const Moose::StateArg & state) const override final;
  ValueType evaluate(const ElemQpArg & qp, const Moose::StateArg & state) const override final;
  ValueType evaluate(const ElemSideQpArg & elem_side_qp,
                     const Moose::StateArg & state) const override final;
  ValueType evaluate(const ElemPointArg & elem_point,
                     const Moose::StateArg & state) const override final;
  ValueType evaluate(const NodeArg & node, const Moose::StateArg & state) const override final;
  ValueType evaluate(const Moose::StateArg & state) const;
 
  GradientType evaluateGradient(const ElemArg & elem,
                                const Moose::StateArg & state) const override final;
  GradientType evaluateGradient(const FaceArg & face,
                                const Moose::StateArg & state) const override final;
  GradientType evaluateGradient(const ElemQpArg & qp,
                                const Moose::StateArg & state) const override final;
  GradientType evaluateGradient(const ElemSideQpArg & elem_side_qp,
                                const Moose::StateArg & state) const override final;
  GradientType evaluateGradient(const ElemPointArg & elem_point,
                                const Moose::StateArg & state) const override final;
  GradientType evaluateGradient(const NodeArg & node,
                                const Moose::StateArg & state) const override final;
 
  void computeAD(bool nodal_ordering);
 
  std::set<TagID> _required_vector_tags;
};