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;
};