Function.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 "FunctionBase.h"
#include "MooseFunctor.h"
#include "ChainedReal.h"
 
// libMesh
#include "libmesh/vector_value.h"
 
// libMesh forward declarations
namespace libMesh
{
class Point;
}
 
class Function : public Moose::FunctionBase, public Moose::FunctorBase<Real>
{
public:
  static InputParameters validParams();
 
  Function(const InputParameters & parameters);
 
  virtual ~Function();
 
  virtual Real value(Real t, const Point & p) const;
 
  virtual ADReal value(const ADReal & t, const ADPoint & p) const;
 
  ChainedReal value(const ChainedReal & t) const;
  template <typename U>
  auto value(const U & t) const;
  template <typename U>
  auto value(const U & t, const U & x, const U & y = 0, const U & z = 0) const;
 
  virtual RealVectorValue vectorValue(Real t, const Point & p) const;
 
  virtual RealVectorValue curl(Real t, const Point & p) const;
 
  virtual Real div(Real t, const Point & p) const;
 
  using Moose::FunctorBase<Real>::gradient;
  virtual RealGradient gradient(Real t, const Point & p) const;
 
  virtual Real timeDerivative(Real t, const Point & p) const;
 
  template <typename U>
  auto timeDerivative(const U & t) const;
  template <typename U>
  auto timeDerivative(const U & t, const U & x, const U & y = 0, const U & z = 0) const;
 
  virtual Real integral() const;
 
  virtual Real average() const;
 
  virtual Real timeIntegral(Real t1, Real t2, const Point & p) const;
 
  void timestepSetup() override;
  // We will only allow initialSetup() and timestepSetup() to be overriden
  void residualSetup() override final;
  void jacobianSetup() override final;
  void customSetup(const ExecFlagType & exec_type) override final;
 
  bool hasBlocks(SubdomainID) const override { return true; }
 
  bool supportsFaceArg() const override final { return true; }
  bool supportsElemSideQpArg() const override final { return true; }
 
private:
  using typename Moose::FunctorBase<Real>::ValueType;
  using typename Moose::FunctorBase<Real>::GradientType;
  using typename Moose::FunctorBase<Real>::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;
 
  template <typename R>
  ValueType evaluateHelper(const R & r, const Moose::StateArg & state) const;
 
  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;
 
  template <typename R>
  GradientType evaluateGradientHelper(const R & r, 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;
 
  template <typename R>
  DotType evaluateDotHelper(const R & r, const Moose::StateArg & state) const;
  DotType evaluateDot(const ElemArg & elem, const Moose::StateArg & state) const override final;
  DotType evaluateDot(const FaceArg & face, const Moose::StateArg & state) const override final;
  DotType evaluateDot(const ElemQpArg & qp, const Moose::StateArg & state) const override final;
  DotType evaluateDot(const ElemSideQpArg & elem_side_qp,
                      const Moose::StateArg & state) const override final;
  DotType evaluateDot(const ElemPointArg & elem_point,
                      const Moose::StateArg & state) const override final;
  DotType evaluateDot(const NodeArg & node, const Moose::StateArg & state) const override final;
};
 
template <typename U>
auto
Function::value(const U & t) const
{
  static const Moose::GenericType<Point, Moose::IsADType<U>::value> p;
  return value(t, p);
}
 
template <typename U>
auto
Function::value(const U & t, const U & x, const U & y, const U & z) const
{
  Moose::GenericType<Point, Moose::IsADType<U>::value> p(x, y, z);
  return value(t, p);
}
 
template <typename U>
auto
Function::timeDerivative(const U & t) const
{
  static const Moose::GenericType<Point, Moose::IsADType<U>::value> p;
  return timeDerivative(t, p);
}
 
template <typename U>
auto
Function::timeDerivative(const U & t, const U & x, const U & y, const U & z) const
{
  Moose::GenericType<Point, Moose::IsADType<U>::value> p(x, y, z);
  return timeDerivative(t, p);
}