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 "MooseObject.h"
#include "SetupInterface.h"
#include "TransientInterface.h"
#include "PostprocessorInterface.h"
#include "UserObjectInterface.h"
#include "Restartable.h"
#include "MeshChangedInterface.h"
#include "ScalarCoupleable.h"
#include "MooseFunctor.h"
#include "ChainedReal.h"

// libMesh
#include "libmesh/vector_value.h"

// libMesh forward declarations
namespace libMesh
{
class Point;
}

class Function : public MooseObject,
                 public SetupInterface,
                 public TransientInterface,
                 public PostprocessorInterface,
                 public UserObjectInterface,
                 public Restartable,
                 public MeshChangedInterface,
                 public ScalarCoupleable,
                 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);
}