https://mooseframework.inl.gov
Public Types | Public Member Functions | Private Attributes | List of all members
Moose::RawValueFunctor< T > Class Template Reference

#include <RawValueFunctor.h>

Inheritance diagram for Moose::RawValueFunctor< T >:
[legend]

Public Types

using FunctorType = FunctorBase< T >
 
using ValueType = T
 
using GradientType = typename FunctorReturnType< T, FunctorEvaluationKind::Gradient >::type
 This rigmarole makes it so that a user can create functors that return containers (std::vector, std::array). More...
 
using DotType = ValueType
 

Public Member Functions

 RawValueFunctor (const FunctorBase< typename ADType< T >::type > &ad_functor)
 
virtual bool isExtrapolatedBoundaryFace (const FaceInfo &fi, const Elem *const elem, const Moose::StateArg &state) const override
 Returns whether this (sided) face is an extrapolated boundary face for this functor. More...
 
virtual bool isConstant () const override
 Returns true if this functor is a constant. More...
 
virtual bool hasBlocks (const SubdomainID id) const override
 Returns whether the functor is defined on this block. More...
 
virtual bool hasFaceSide (const FaceInfo &fi, const bool fi_elem_side) const override
 
bool supportsFaceArg () const override final
 Whether this functor supports evaluation with FaceArg. More...
 
bool supportsElemSideQpArg () const override final
 Whether this functor supports evaluation with ElemSideQpArg. More...
 
template<FunctorEvaluationKind FET, typename Space , typename State >
FunctorReturnType< T, FET >::type genericEvaluate (const Space &r, const State &state) const
 Perform a generic evaluation based on the supplied template argument FET and supplied spatial and temporal arguments. More...
 
const MooseFunctorName & functorName () const
 Return the functor name. More...
 
virtual void residualSetup () override
 
virtual void jacobianSetup () override
 
virtual void timestepSetup () override
 
virtual void customSetup (const ExecFlagType &exec_type) override
 
void setCacheClearanceSchedule (const std::set< ExecFlagType > &clearance_schedule)
 Set how often to clear the functor evaluation cache. More...
 
bool isInternalFace (const FaceInfo &) const
 Returns true if the face is an internal face. More...
 
void checkFace (const Moose::FaceArg &face) const
 Examines the incoming face argument. More...
 
ValueType operator() (const ElemArg &elem, const StateArg &state) const
 Same as their evaluate overloads with the same arguments but allows for caching implementation. More...
 
ValueType operator() (const FaceArg &face, const StateArg &state) const
 
ValueType operator() (const ElemQpArg &qp, const StateArg &state) const
 
ValueType operator() (const ElemSideQpArg &qp, const StateArg &state) const
 
ValueType operator() (const ElemPointArg &elem_point, const StateArg &state) const
 
ValueType operator() (const NodeArg &node, const StateArg &state) const
 
GradientType gradient (const ElemArg &elem, const StateArg &state) const
 Same as their evaluateGradient overloads with the same arguments but allows for caching implementation. More...
 
GradientType gradient (const FaceArg &face, const StateArg &state) const
 
GradientType gradient (const ElemQpArg &qp, const StateArg &state) const
 
GradientType gradient (const ElemSideQpArg &qp, const StateArg &state) const
 
GradientType gradient (const ElemPointArg &elem_point, const StateArg &state) const
 
GradientType gradient (const NodeArg &node, const StateArg &state) const
 
DotType dot (const ElemArg &elem, const StateArg &state) const
 Same as their evaluateDot overloads with the same arguments but allows for caching implementation. More...
 
DotType dot (const FaceArg &face, const StateArg &state) const
 
DotType dot (const ElemQpArg &qp, const StateArg &state) const
 
DotType dot (const ElemSideQpArg &qp, const StateArg &state) const
 
DotType dot (const ElemPointArg &elem_point, const StateArg &state) const
 
DotType dot (const NodeArg &node, const StateArg &state) const
 
GradientType gradDot (const ElemArg &elem, const StateArg &state) const
 Same as their evaluateGradDot overloads with the same arguments but allows for caching implementation. More...
 
GradientType gradDot (const FaceArg &face, const StateArg &state) const
 
GradientType gradDot (const ElemQpArg &qp, const StateArg &state) const
 
GradientType gradDot (const ElemSideQpArg &qp, const StateArg &state) const
 
GradientType gradDot (const ElemPointArg &elem_point, const StateArg &state) const
 
GradientType gradDot (const NodeArg &node, const StateArg &state) const
 

Protected Member Functions

ValueType evaluate (const ElemArg &elem, const StateArg &state) const override
 Forward calls to wrapped object. More...
 
ValueType evaluate (const FaceArg &face, const StateArg &state) const override
 
ValueType evaluate (const ElemQpArg &qp, const StateArg &state) const override
 
ValueType evaluate (const ElemSideQpArg &qp, const StateArg &state) const override
 
ValueType evaluate (const ElemPointArg &elem_point, const StateArg &state) const override
 Evaluate the functor with a given element and point. More...
 
ValueType evaluate (const NodeArg &node, const StateArg &state) const override
 
GradientType evaluateGradient (const ElemArg &elem, const StateArg &state) const override
 Evaluate the functor gradient with a given element. More...
 
GradientType evaluateGradient (const FaceArg &face, const StateArg &state) const override
 
GradientType evaluateGradient (const ElemQpArg &qp, const StateArg &state) const override
 
GradientType evaluateGradient (const ElemSideQpArg &qp, const StateArg &state) const override
 
GradientType evaluateGradient (const ElemPointArg &elem_point, const StateArg &state) const override
 Evaluate the functor gradient with a given element and point. More...
 
GradientType evaluateGradient (const NodeArg &node, const StateArg &state) const override
 
DotType evaluateDot (const ElemArg &elem, const StateArg &state) const override
 Evaluate the functor time derivative with a given element. More...
 
DotType evaluateDot (const FaceArg &face, const StateArg &state) const override
 
DotType evaluateDot (const ElemQpArg &qp, const StateArg &state) const override
 
DotType evaluateDot (const ElemSideQpArg &qp, const StateArg &state) const override
 
DotType evaluateDot (const ElemPointArg &elem_point, const StateArg &state) const override
 Evaluate the functor time derivative with a given element and point. More...
 
DotType evaluateDot (const NodeArg &node, const StateArg &state) const override
 
GradientType evaluateGradDot (const ElemArg &elem, const StateArg &state) const override
 Evaluate the functor gradient-dot with a given element. More...
 
GradientType evaluateGradDot (const FaceArg &face, const StateArg &state) const override
 
GradientType evaluateGradDot (const ElemQpArg &qp, const StateArg &state) const override
 
GradientType evaluateGradDot (const ElemSideQpArg &qp, const StateArg &state) const override
 
GradientType evaluateGradDot (const ElemPointArg &elem_point, const StateArg &state) const override
 Evaluate the functor gradient-dot with a given element and point. More...
 
GradientType evaluateGradDot (const NodeArg &node, const StateArg &state) const override
 

Private Attributes

const FunctorBase< typename ADType< T >::type > & _ad_functor
 Our wrapped AD object. More...
 

Detailed Description

template<typename T>
class Moose::RawValueFunctor< T >

Definition at line 17 of file RawValueFunctor.h.

Member Typedef Documentation

◆ DotType

template<typename T>
using Moose::FunctorBase< T >::DotType = ValueType
inherited

Definition at line 150 of file MooseFunctor.h.

◆ FunctorType

template<typename T>
using Moose::FunctorBase< T >::FunctorType = FunctorBase<T>
inherited

Definition at line 140 of file MooseFunctor.h.

◆ GradientType

template<typename T>
using Moose::FunctorBase< T >::GradientType = typename FunctorReturnType<T, FunctorEvaluationKind::Gradient>::type
inherited

This rigmarole makes it so that a user can create functors that return containers (std::vector, std::array).

This logic will make it such that if a user requests a functor type T that is a container of algebraic types, for example Reals, then the GradientType will be a container of the gradients of those algebraic types, in this example VectorValue<Reals>. So if T is std::vector<Real>, then GradientType will be std::vector<VectorValue<Real>>. As another example: T = std::array<VectorValue<Real>, 1> -> GradientType = std::array<TensorValue<Real>, 1>

Definition at line 149 of file MooseFunctor.h.

◆ ValueType

template<typename T>
using Moose::FunctorBase< T >::ValueType = T
inherited

Definition at line 141 of file MooseFunctor.h.

Constructor & Destructor Documentation

◆ RawValueFunctor()

template<typename T >
Moose::RawValueFunctor< T >::RawValueFunctor ( const FunctorBase< typename ADType< T >::type > &  ad_functor)
inline

Definition at line 24 of file RawValueFunctor.h.

25  : FunctorBase<T>(ad_functor.functorName() + "_raw_value", {EXEC_ALWAYS}),
26  _ad_functor(ad_functor)
27  {
28  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
EXEC_ALWAYS
const ExecFlagType EXEC_ALWAYS
Definition: Moose.C:51

Member Function Documentation

◆ checkFace()

template<typename T>
void Moose::FunctorBase< T >::checkFace ( const Moose::FaceArg &  face) const
inherited

Examines the incoming face argument.

If the face argument producer (residual object, postprocessor, etc.) did not indicate a sidedness to the face, e.g. if the face_side member of the FaceArg is nullptr, then we may "modify" the sidedness of the argument if we are only defined on one side of the face. If the face argument producer has indicated a sidedness and we are not defined on that side, then we will error

Parameters
faceThe face argument created by the face argument producer, likely a residual object
Returns
A face with possibly changed sidedness depending on whether we aren't defined on both sides of the face

Definition at line 732 of file MooseFunctor.h.

737 {
738 #if DEBUG
739  const Elem * const elem = face.face_side;
740  const FaceInfo * const fi = face.fi;
741  mooseAssert(fi, "face info should be non-null");
742  bool check_elem_def = false;
743  bool check_neighbor_def = false;
744  // We check if the functor is defined on both sides of the face
745  if (!elem)
746  {
747  if (!hasFaceSide(*fi, true))
748  check_neighbor_def = true;
749  else if (!hasFaceSide(*fi, false))
750  check_elem_def = true;
751  }
752  else if (elem == fi->elemPtr())
753  check_elem_def = true;
754  else
755  {
756  mooseAssert(elem == fi->neighborPtr(), "This has to match something");
757  check_neighbor_def = true;
758  }
759 
760  if (check_elem_def && !hasFaceSide(*fi, true))
761  {
762  std::string additional_message = "It is not defined on the neighbor side either.";
763  if (hasFaceSide(*fi, false))
764  additional_message = "It is however defined on the neighbor side.";
765  additional_message += " Face centroid: " + Moose::stringify(fi->faceCentroid());
766  mooseError(_functor_name,
767  " is not defined on the element side of the face information, but a face argument "
768  "producer "
769  "(e.g. residual object, postprocessor, etc.) has requested evaluation there.\n",
770  additional_message);
771  }
772  if (check_neighbor_def && !hasFaceSide(*fi, false))
773  {
774  std::string additional_message = "It is not defined on the element side either.";
775  if (hasFaceSide(*fi, true))
776  additional_message = "It is however defined on the element side.";
777  additional_message += " Face centroid: " + Moose::stringify(fi->faceCentroid());
778  mooseError(
779  _functor_name,
780  " is not defined on the neighbor side of the face information, but a face argument "
781  "producer (e.g. residual object, postprocessor, etc.) has requested evaluation there.\n",
782  additional_message);
783  }
784 #endif
785 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:323
Moose::FaceArg::face_side
const libMesh::Elem * face_side
A member that can be used to indicate whether there is a sidedness to this face.
Definition: MooseFunctorArguments.h:206
FaceInfo::faceCentroid
const Point & faceCentroid() const
Returns the coordinates of the face centroid.
Definition: FaceInfo.h:71
FaceInfo
This data structure is used to store geometric and variable related metadata about each cell face in ...
Definition: FaceInfo.h:36
FaceInfo::neighborPtr
const Elem * neighborPtr() const
Definition: FaceInfo.h:84
Moose::FunctorBase::_functor_name
MooseFunctorName _functor_name
name of the functor
Definition: MooseFunctor.h:564
Moose::FaceArg::fi
const FaceInfo * fi
a face information object which defines our location in space
Definition: MooseFunctorArguments.h:185
Moose::stringify
std::string stringify(const T &t)
conversion to string
Definition: Conversion.h:64
FaceInfo::elemPtr
const Elem * elemPtr() const
Definition: FaceInfo.h:82
Moose::FunctorBase::hasFaceSide
virtual bool hasFaceSide(const FaceInfo &fi, const bool fi_elem_side) const override
Definition: MooseFunctor.h:976

◆ customSetup()

template<typename T >
void Moose::FunctorBase< T >::customSetup ( const ExecFlagType &  exec_type)
overridevirtualinherited

Implements Moose::FunctorAbstract.

Reimplemented in Function.

Definition at line 839 of file MooseFunctor.h.

840 {
841  if (_clearance_schedule.count(exec_type))
842  clearCacheData();
843 }
Moose::FunctorBase::clearCacheData
void clearCacheData()
clear cache data
Definition: MooseFunctor.h:789
Moose::FunctorBase::_clearance_schedule
std::set< ExecFlagType > _clearance_schedule
How often to clear the material property cache.
Definition: MooseFunctor.h:514

◆ dot() [1/6]

template<typename T >
FunctorBase< T >::DotType Moose::FunctorBase< T >::dot ( const ElemArg &  elem,
const StateArg &  state 
) const
inherited

Same as their evaluateDot overloads with the same arguments but allows for caching implementation.

These are the methods a user will call in their code

Definition at line 890 of file MooseFunctor.h.

Referenced by FVFunctorTimeKernel::computeQpResidual(), and Moose::ADWrapperFunctor< T >::evaluateDot().

891 {
892  return evaluateDot(elem, state);
893 }
Moose::FunctorBase::evaluateDot
virtual DotType evaluateDot(const ElemArg &, const StateArg &) const
Evaluate the functor time derivative with a given element.
Definition: MooseFunctor.h:385

◆ dot() [2/6]

template<typename T >
FunctorBase< T >::DotType Moose::FunctorBase< T >::dot ( const FaceArg &  face,
const StateArg &  state 
) const
inherited

Definition at line 897 of file MooseFunctor.h.

898 {
899  checkFace(face);
900  return evaluateDot(face, state);
901 }
Moose::FunctorBase::evaluateDot
virtual DotType evaluateDot(const ElemArg &, const StateArg &) const
Evaluate the functor time derivative with a given element.
Definition: MooseFunctor.h:385
Moose::FunctorBase::checkFace
void checkFace(const Moose::FaceArg &face) const
Examines the incoming face argument.
Definition: MooseFunctor.h:732

◆ dot() [3/6]

template<typename T >
FunctorBase< T >::DotType Moose::FunctorBase< T >::dot ( const ElemQpArg &  qp,
const StateArg &  state 
) const
inherited

Definition at line 905 of file MooseFunctor.h.

906 {
907  return evaluateDot(elem_qp, state);
908 }
Moose::FunctorBase::evaluateDot
virtual DotType evaluateDot(const ElemArg &, const StateArg &) const
Evaluate the functor time derivative with a given element.
Definition: MooseFunctor.h:385

◆ dot() [4/6]

template<typename T >
FunctorBase< T >::DotType Moose::FunctorBase< T >::dot ( const ElemSideQpArg &  qp,
const StateArg &  state 
) const
inherited

Definition at line 912 of file MooseFunctor.h.

913 {
914  return evaluateDot(elem_side_qp, state);
915 }
Moose::FunctorBase::evaluateDot
virtual DotType evaluateDot(const ElemArg &, const StateArg &) const
Evaluate the functor time derivative with a given element.
Definition: MooseFunctor.h:385

◆ dot() [5/6]

template<typename T >
FunctorBase< T >::DotType Moose::FunctorBase< T >::dot ( const ElemPointArg &  elem_point,
const StateArg &  state 
) const
inherited

Definition at line 919 of file MooseFunctor.h.

920 {
921  return evaluateDot(elem_point, state);
922 }
Moose::FunctorBase::evaluateDot
virtual DotType evaluateDot(const ElemArg &, const StateArg &) const
Evaluate the functor time derivative with a given element.
Definition: MooseFunctor.h:385

◆ dot() [6/6]

template<typename T >
FunctorBase< T >::DotType Moose::FunctorBase< T >::dot ( const NodeArg &  node,
const StateArg &  state 
) const
inherited

Definition at line 926 of file MooseFunctor.h.

927 {
928  return evaluateDot(node, state);
929 }
Moose::FunctorBase::evaluateDot
virtual DotType evaluateDot(const ElemArg &, const StateArg &) const
Evaluate the functor time derivative with a given element.
Definition: MooseFunctor.h:385

◆ evaluate() [1/6]

template<typename T >
ValueType Moose::RawValueFunctor< T >::evaluate ( const ElemArg &  elem,
const StateArg &  state 
) const
inlineoverrideprotectedvirtual

Forward calls to wrapped object.

Implements Moose::FunctorBase< T >.

Definition at line 51 of file RawValueFunctor.h.

52  {
53  return MetaPhysicL::raw_value(_ad_functor(elem, state));
54  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluate() [2/6]

template<typename T >
ValueType Moose::RawValueFunctor< T >::evaluate ( const FaceArg &  face,
const StateArg &  state 
) const
inlineoverrideprotectedvirtual
Parameters
faceSee the FaceArg doxygen
stateSee the StateArg doxygen
Returns
The functor evaluated at the requested state and space

Implements Moose::FunctorBase< T >.

Definition at line 55 of file RawValueFunctor.h.

56  {
57  return MetaPhysicL::raw_value(_ad_functor(face, state));
58  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluate() [3/6]

template<typename T >
ValueType Moose::RawValueFunctor< T >::evaluate ( const ElemQpArg &  qp,
const StateArg &  state 
) const
inlineoverrideprotectedvirtual
Parameters
qpSee the ElemQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor evaluated at the requested state and space

Implements Moose::FunctorBase< T >.

Definition at line 59 of file RawValueFunctor.h.

60  {
61  return MetaPhysicL::raw_value(_ad_functor(qp, state));
62  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluate() [4/6]

template<typename T >
ValueType Moose::RawValueFunctor< T >::evaluate ( const ElemSideQpArg &  side_qp,
const StateArg &  state 
) const
inlineoverrideprotectedvirtual
Parameters
side_qpSee the ElemSideQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor evaluated at the requested state and space

Implements Moose::FunctorBase< T >.

Definition at line 63 of file RawValueFunctor.h.

64  {
65  return MetaPhysicL::raw_value(_ad_functor(qp, state));
66  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluate() [5/6]

template<typename T >
ValueType Moose::RawValueFunctor< T >::evaluate ( const ElemPointArg &  elem_point,
const StateArg &  state 
) const
inlineoverrideprotectedvirtual

Evaluate the functor with a given element and point.

Some example implementations of this method could perform a two-term Taylor expansion using cell-centered value and gradient

Implements Moose::FunctorBase< T >.

Definition at line 67 of file RawValueFunctor.h.

68  {
69  return MetaPhysicL::raw_value(_ad_functor(elem_point, state));
70  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluate() [6/6]

template<typename T >
ValueType Moose::RawValueFunctor< T >::evaluate ( const NodeArg &  node,
const StateArg &  state 
) const
inlineoverrideprotectedvirtual

Implements Moose::FunctorBase< T >.

Definition at line 71 of file RawValueFunctor.h.

72  {
73  return MetaPhysicL::raw_value(_ad_functor(node, state));
74  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateDot() [1/6]

template<typename T >
DotType Moose::RawValueFunctor< T >::evaluateDot ( const ElemArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual

Evaluate the functor time derivative with a given element.

Some example implementations of this method could compute an element-average or evaluate at the element centroid

Reimplemented from Moose::FunctorBase< T >.

Definition at line 102 of file RawValueFunctor.h.

103  {
104  return MetaPhysicL::raw_value(_ad_functor.dot(elem, state));
105  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateDot() [2/6]

template<typename T >
DotType Moose::RawValueFunctor< T >::evaluateDot ( const FaceArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual
Parameters
faceSee the FaceArg doxygen
stateSee the StateArg doxygen
Returns
The functor time derivative evaluated at the requested state and space

Reimplemented from Moose::FunctorBase< T >.

Definition at line 106 of file RawValueFunctor.h.

107  {
108  return MetaPhysicL::raw_value(_ad_functor.dot(face, state));
109  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateDot() [3/6]

template<typename T >
DotType Moose::RawValueFunctor< T >::evaluateDot ( const ElemQpArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual
Parameters
qpSee the ElemQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor time derivative evaluated at the requested state and space

Reimplemented from Moose::FunctorBase< T >.

Definition at line 110 of file RawValueFunctor.h.

111  {
112  return MetaPhysicL::raw_value(_ad_functor.dot(qp, state));
113  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateDot() [4/6]

template<typename T >
DotType Moose::RawValueFunctor< T >::evaluateDot ( const ElemSideQpArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual
Parameters
side_qpSee the ElemSideQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor time derivative evaluated at the requested state and space

Reimplemented from Moose::FunctorBase< T >.

Definition at line 114 of file RawValueFunctor.h.

115  {
116  return MetaPhysicL::raw_value(_ad_functor.dot(qp, state));
117  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateDot() [5/6]

template<typename T >
DotType Moose::RawValueFunctor< T >::evaluateDot ( const ElemPointArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual

Evaluate the functor time derivative with a given element and point.

Reimplemented from Moose::FunctorBase< T >.

Definition at line 118 of file RawValueFunctor.h.

119  {
120  return MetaPhysicL::raw_value(_ad_functor.dot(elem_point, state));
121  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateDot() [6/6]

template<typename T >
DotType Moose::RawValueFunctor< T >::evaluateDot ( const NodeArg &  node,
const StateArg &  state 
) const
inlineoverrideprotectedvirtual

Reimplemented from Moose::FunctorBase< T >.

Definition at line 122 of file RawValueFunctor.h.

123  {
124  return MetaPhysicL::raw_value(_ad_functor.dot(node, state));
125  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateGradDot() [1/6]

template<typename T >
GradientType Moose::RawValueFunctor< T >::evaluateGradDot ( const ElemArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual

Evaluate the functor gradient-dot with a given element.

Some example implementations of this method could compute an element-average or evaluate at the element centroid

Reimplemented from Moose::FunctorBase< T >.

Definition at line 127 of file RawValueFunctor.h.

128  {
129  return MetaPhysicL::raw_value(_ad_functor.gradDot(elem, state));
130  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateGradDot() [2/6]

template<typename T >
GradientType Moose::RawValueFunctor< T >::evaluateGradDot ( const FaceArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual
Parameters
faceSee the FaceArg doxygen
stateSee the StateArg doxygen
Returns
The functor gradient-dot evaluated at the requested state and space

Reimplemented from Moose::FunctorBase< T >.

Definition at line 131 of file RawValueFunctor.h.

132  {
133  return MetaPhysicL::raw_value(_ad_functor.gradDot(face, state));
134  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateGradDot() [3/6]

template<typename T >
GradientType Moose::RawValueFunctor< T >::evaluateGradDot ( const ElemQpArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual
Parameters
qpSee the ElemQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor gradient-dot evaluated at the requested state and space

Reimplemented from Moose::FunctorBase< T >.

Definition at line 135 of file RawValueFunctor.h.

136  {
137  return MetaPhysicL::raw_value(_ad_functor.gradDot(qp, state));
138  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateGradDot() [4/6]

template<typename T >
GradientType Moose::RawValueFunctor< T >::evaluateGradDot ( const ElemSideQpArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual
Parameters
side_qpSee the ElemSideQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor gradient-dot evaluated at the requested state and space

Reimplemented from Moose::FunctorBase< T >.

Definition at line 139 of file RawValueFunctor.h.

140  {
141  return MetaPhysicL::raw_value(_ad_functor.gradDot(qp, state));
142  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateGradDot() [5/6]

template<typename T >
GradientType Moose::RawValueFunctor< T >::evaluateGradDot ( const ElemPointArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual

Evaluate the functor gradient-dot with a given element and point.

Reimplemented from Moose::FunctorBase< T >.

Definition at line 143 of file RawValueFunctor.h.

145  {
146  return MetaPhysicL::raw_value(_ad_functor.gradDot(elem_point, state));
147  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateGradDot() [6/6]

template<typename T >
GradientType Moose::RawValueFunctor< T >::evaluateGradDot ( const NodeArg &  node,
const StateArg &  state 
) const
inlineoverrideprotectedvirtual

Reimplemented from Moose::FunctorBase< T >.

Definition at line 148 of file RawValueFunctor.h.

149  {
150  return MetaPhysicL::raw_value(_ad_functor.gradDot(node, state));
151  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateGradient() [1/6]

template<typename T >
GradientType Moose::RawValueFunctor< T >::evaluateGradient ( const ElemArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual

Evaluate the functor gradient with a given element.

Some example implementations of this method could compute an element-average or evaluate at the element centroid

Reimplemented from Moose::FunctorBase< T >.

Definition at line 76 of file RawValueFunctor.h.

77  {
78  return MetaPhysicL::raw_value(_ad_functor.gradient(elem, state));
79  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateGradient() [2/6]

template<typename T >
GradientType Moose::RawValueFunctor< T >::evaluateGradient ( const FaceArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual
Parameters
faceSee the FaceArg doxygen
stateSee the StateArg doxygen
Returns
The functor gradient evaluated at the requested state and space

Reimplemented from Moose::FunctorBase< T >.

Definition at line 80 of file RawValueFunctor.h.

81  {
82  return MetaPhysicL::raw_value(_ad_functor.gradient(face, state));
83  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateGradient() [3/6]

template<typename T >
GradientType Moose::RawValueFunctor< T >::evaluateGradient ( const ElemQpArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual
Parameters
qpSee the ElemQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor gradient evaluated at the requested state and space

Reimplemented from Moose::FunctorBase< T >.

Definition at line 84 of file RawValueFunctor.h.

85  {
86  return MetaPhysicL::raw_value(_ad_functor.gradient(qp, state));
87  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateGradient() [4/6]

template<typename T >
GradientType Moose::RawValueFunctor< T >::evaluateGradient ( const ElemSideQpArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual
Parameters
side_qpSee the ElemSideQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor gradient evaluated at the requested state and space

Reimplemented from Moose::FunctorBase< T >.

Definition at line 88 of file RawValueFunctor.h.

89  {
90  return MetaPhysicL::raw_value(_ad_functor.gradient(qp, state));
91  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateGradient() [5/6]

template<typename T >
GradientType Moose::RawValueFunctor< T >::evaluateGradient ( const ElemPointArg &  ,
const StateArg &   
) const
inlineoverrideprotectedvirtual

Evaluate the functor gradient with a given element and point.

Reimplemented from Moose::FunctorBase< T >.

Definition at line 92 of file RawValueFunctor.h.

94  {
95  return MetaPhysicL::raw_value(_ad_functor.gradient(elem_point, state));
96  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ evaluateGradient() [6/6]

template<typename T >
GradientType Moose::RawValueFunctor< T >::evaluateGradient ( const NodeArg &  node,
const StateArg &  state 
) const
inlineoverrideprotectedvirtual

Reimplemented from Moose::FunctorBase< T >.

Definition at line 97 of file RawValueFunctor.h.

98  {
99  return MetaPhysicL::raw_value(_ad_functor.gradient(node, state));
100  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:73

◆ functorName()

template<typename T>
const MooseFunctorName& Moose::FunctorBase< T >::functorName ( ) const
inlineinherited

Return the functor name.

Definition at line 170 of file MooseFunctor.h.

Referenced by Moose::FunctorBase< libMesh::VectorValue >::evaluateDot(), Moose::FunctorBase< libMesh::VectorValue >::evaluateGradDot(), Moose::FunctorBase< libMesh::VectorValue >::evaluateGradient(), and Moose::FunctorBase< libMesh::VectorValue >::hasBlocks().

170 { return _functor_name; }
Moose::FunctorBase::_functor_name
MooseFunctorName _functor_name
name of the functor
Definition: MooseFunctor.h:564

◆ genericEvaluate()

template<typename T >
template<FunctorEvaluationKind FET, typename Space , typename State >
FunctorReturnType< T, FET >::type Moose::FunctorBase< T >::genericEvaluate ( const Space &  r,
const State &  state 
) const
inherited

Perform a generic evaluation based on the supplied template argument FET and supplied spatial and temporal arguments.

Definition at line 987 of file MooseFunctor.h.

988 {
989  if constexpr (FET == FunctorEvaluationKind::Value)
990  return (*this)(r, state);
991  else if constexpr (FET == FunctorEvaluationKind::Gradient)
992  return gradient(r, state);
993  else if constexpr (FET == FunctorEvaluationKind::Dot)
994  return dot(r, state);
995  else
996  return gradDot(r, state);
997 }
Moose::FunctorBase::gradDot
GradientType gradDot(const ElemArg &elem, const StateArg &state) const
Same as their evaluateGradDot overloads with the same arguments but allows for caching implementation...
Definition: MooseFunctor.h:933
Moose::FunctorBase::dot
DotType dot(const ElemArg &elem, const StateArg &state) const
Same as their evaluateDot overloads with the same arguments but allows for caching implementation...
Definition: MooseFunctor.h:890
Moose::FunctorBase::gradient
GradientType gradient(const ElemArg &elem, const StateArg &state) const
Same as their evaluateGradient overloads with the same arguments but allows for caching implementatio...
Definition: MooseFunctor.h:847

◆ gradDot() [1/6]

template<typename T >
FunctorBase< T >::GradientType Moose::FunctorBase< T >::gradDot ( const ElemArg &  elem,
const StateArg &  state 
) const
inherited

Same as their evaluateGradDot overloads with the same arguments but allows for caching implementation.

These are the methods a user will call in their code

Definition at line 933 of file MooseFunctor.h.

Referenced by Moose::VectorComponentFunctor< T >::evaluateGradDot(), and Moose::ADWrapperFunctor< T >::evaluateGradDot().

934 {
935  return evaluateGradDot(elem, state);
936 }
Moose::FunctorBase::evaluateGradDot
virtual GradientType evaluateGradDot(const ElemArg &, const StateArg &) const
Evaluate the functor gradient-dot with a given element.
Definition: MooseFunctor.h:439

◆ gradDot() [2/6]

template<typename T >
FunctorBase< T >::GradientType Moose::FunctorBase< T >::gradDot ( const FaceArg &  face,
const StateArg &  state 
) const
inherited

Definition at line 940 of file MooseFunctor.h.

941 {
942  checkFace(face);
943  return evaluateGradDot(face, state);
944 }
Moose::FunctorBase::checkFace
void checkFace(const Moose::FaceArg &face) const
Examines the incoming face argument.
Definition: MooseFunctor.h:732
Moose::FunctorBase::evaluateGradDot
virtual GradientType evaluateGradDot(const ElemArg &, const StateArg &) const
Evaluate the functor gradient-dot with a given element.
Definition: MooseFunctor.h:439

◆ gradDot() [3/6]

template<typename T >
FunctorBase< T >::GradientType Moose::FunctorBase< T >::gradDot ( const ElemQpArg &  qp,
const StateArg &  state 
) const
inherited

Definition at line 948 of file MooseFunctor.h.

949 {
950  return evaluateGradDot(elem_qp, state);
951 }
Moose::FunctorBase::evaluateGradDot
virtual GradientType evaluateGradDot(const ElemArg &, const StateArg &) const
Evaluate the functor gradient-dot with a given element.
Definition: MooseFunctor.h:439

◆ gradDot() [4/6]

template<typename T >
FunctorBase< T >::GradientType Moose::FunctorBase< T >::gradDot ( const ElemSideQpArg &  qp,
const StateArg &  state 
) const
inherited

Definition at line 955 of file MooseFunctor.h.

956 {
957  return evaluateGradDot(elem_side_qp, state);
958 }
Moose::FunctorBase::evaluateGradDot
virtual GradientType evaluateGradDot(const ElemArg &, const StateArg &) const
Evaluate the functor gradient-dot with a given element.
Definition: MooseFunctor.h:439

◆ gradDot() [5/6]

template<typename T >
FunctorBase< T >::GradientType Moose::FunctorBase< T >::gradDot ( const ElemPointArg &  elem_point,
const StateArg &  state 
) const
inherited

Definition at line 962 of file MooseFunctor.h.

963 {
964  return evaluateGradDot(elem_point, state);
965 }
Moose::FunctorBase::evaluateGradDot
virtual GradientType evaluateGradDot(const ElemArg &, const StateArg &) const
Evaluate the functor gradient-dot with a given element.
Definition: MooseFunctor.h:439

◆ gradDot() [6/6]

template<typename T >
FunctorBase< T >::GradientType Moose::FunctorBase< T >::gradDot ( const NodeArg &  node,
const StateArg &  state 
) const
inherited

Definition at line 969 of file MooseFunctor.h.

970 {
971  return evaluateGradDot(node, state);
972 }
Moose::FunctorBase::evaluateGradDot
virtual GradientType evaluateGradDot(const ElemArg &, const StateArg &) const
Evaluate the functor gradient-dot with a given element.
Definition: MooseFunctor.h:439

◆ gradient() [1/6]

template<typename T >
FunctorBase< T >::GradientType Moose::FunctorBase< T >::gradient ( const ElemArg &  elem,
const StateArg &  state 
) const
inherited

Same as their evaluateGradient overloads with the same arguments but allows for caching implementation.

These are the methods a user will call in their code

Definition at line 847 of file MooseFunctor.h.

Referenced by GradientJumpIndicator::computeQpIntegral(), Moose::FV::containerInterpolate(), Moose::VectorComponentFunctor< T >::evaluateGradient(), Moose::ADWrapperFunctor< T >::evaluateGradient(), and Moose::FV::greenGaussGradient().

848 {
849  return evaluateGradient(elem, state);
850 }
Moose::FunctorBase::evaluateGradient
virtual GradientType evaluateGradient(const ElemArg &, const StateArg &) const
Evaluate the functor gradient with a given element.
Definition: MooseFunctor.h:332

◆ gradient() [2/6]

template<typename T >
FunctorBase< T >::GradientType Moose::FunctorBase< T >::gradient ( const FaceArg &  face,
const StateArg &  state 
) const
inherited

Definition at line 854 of file MooseFunctor.h.

855 {
856  checkFace(face);
857  return evaluateGradient(face, state);
858 }
Moose::FunctorBase::checkFace
void checkFace(const Moose::FaceArg &face) const
Examines the incoming face argument.
Definition: MooseFunctor.h:732
Moose::FunctorBase::evaluateGradient
virtual GradientType evaluateGradient(const ElemArg &, const StateArg &) const
Evaluate the functor gradient with a given element.
Definition: MooseFunctor.h:332

◆ gradient() [3/6]

template<typename T >
FunctorBase< T >::GradientType Moose::FunctorBase< T >::gradient ( const ElemQpArg &  qp,
const StateArg &  state 
) const
inherited

Definition at line 862 of file MooseFunctor.h.

863 {
864  return evaluateGradient(elem_qp, state);
865 }
Moose::FunctorBase::evaluateGradient
virtual GradientType evaluateGradient(const ElemArg &, const StateArg &) const
Evaluate the functor gradient with a given element.
Definition: MooseFunctor.h:332

◆ gradient() [4/6]

template<typename T >
FunctorBase< T >::GradientType Moose::FunctorBase< T >::gradient ( const ElemSideQpArg &  qp,
const StateArg &  state 
) const
inherited

Definition at line 869 of file MooseFunctor.h.

870 {
871  return evaluateGradient(elem_side_qp, state);
872 }
Moose::FunctorBase::evaluateGradient
virtual GradientType evaluateGradient(const ElemArg &, const StateArg &) const
Evaluate the functor gradient with a given element.
Definition: MooseFunctor.h:332

◆ gradient() [5/6]

template<typename T >
FunctorBase< T >::GradientType Moose::FunctorBase< T >::gradient ( const ElemPointArg &  elem_point,
const StateArg &  state 
) const
inherited

Definition at line 876 of file MooseFunctor.h.

877 {
878  return evaluateGradient(elem_point, state);
879 }
Moose::FunctorBase::evaluateGradient
virtual GradientType evaluateGradient(const ElemArg &, const StateArg &) const
Evaluate the functor gradient with a given element.
Definition: MooseFunctor.h:332

◆ gradient() [6/6]

template<typename T >
FunctorBase< T >::GradientType Moose::FunctorBase< T >::gradient ( const NodeArg &  node,
const StateArg &  state 
) const
inherited

Definition at line 883 of file MooseFunctor.h.

884 {
885  return evaluateGradient(node, state);
886 }
Moose::FunctorBase::evaluateGradient
virtual GradientType evaluateGradient(const ElemArg &, const StateArg &) const
Evaluate the functor gradient with a given element.
Definition: MooseFunctor.h:332

◆ hasBlocks()

template<typename T >
virtual bool Moose::RawValueFunctor< T >::hasBlocks ( const SubdomainID  ) const
inlineoverridevirtual

Returns whether the functor is defined on this block.

Reimplemented from Moose::FunctorBase< T >.

Definition at line 37 of file RawValueFunctor.h.

37 { return _ad_functor.hasBlocks(id); }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156

◆ hasFaceSide()

template<typename T >
virtual bool Moose::RawValueFunctor< T >::hasFaceSide ( const FaceInfo &  fi,
const bool  fi_elem_side 
) const
inlineoverridevirtual

Reimplemented from Moose::FunctorBase< T >.

Definition at line 38 of file RawValueFunctor.h.

39  {
40  return _ad_functor.hasFaceSide(fi, fi_elem_side);
41  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156

◆ isConstant()

template<typename T >
virtual bool Moose::RawValueFunctor< T >::isConstant ( ) const
inlineoverridevirtual

Returns true if this functor is a constant.

Reimplemented from Moose::FunctorBase< T >.

Definition at line 36 of file RawValueFunctor.h.

36 { return _ad_functor.isConstant(); }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156

◆ isExtrapolatedBoundaryFace()

template<typename T >
virtual bool Moose::RawValueFunctor< T >::isExtrapolatedBoundaryFace ( const FaceInfo &  ,
const Elem *const  ,
const Moose::StateArg &   
) const
inlineoverridevirtual

Returns whether this (sided) face is an extrapolated boundary face for this functor.

Reimplemented from Moose::FunctorBase< T >.

Definition at line 30 of file RawValueFunctor.h.

33  {
34  return _ad_functor.isExtrapolatedBoundaryFace(fi, elem, state);
35  }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156

◆ isInternalFace()

template<typename T >
bool Moose::FunctorBase< T >::isInternalFace ( const FaceInfo &  fi) const
inherited

Returns true if the face is an internal face.

Definition at line 569 of file MooseFunctor.h.

Referenced by FVAnisotropicDiffusion::computeQpResidual(), and FVDiffusion::computeQpResidual().

570 {
571  if (!fi.neighborPtr())
572  return false;
573 
574  return hasBlocks(fi.elem().subdomain_id()) && hasBlocks(fi.neighborPtr()->subdomain_id());
575 }
Moose::FunctorBase::hasBlocks
virtual bool hasBlocks(SubdomainID) const
Returns whether the functor is defined on this block.
Definition: MooseFunctor.h:237
FaceInfo::elem
const Elem & elem() const
Definition: FaceInfo.h:81
FaceInfo::neighborPtr
const Elem * neighborPtr() const
Definition: FaceInfo.h:84

◆ jacobianSetup()

template<typename T >
void Moose::FunctorBase< T >::jacobianSetup ( )
overridevirtualinherited

Implements Moose::FunctorAbstract.

Reimplemented in MooseVariableFE< OutputType >, MooseVariableFE< ComputeValueType >, MooseVariableFE< T >, MooseVariableFE< RealEigenVector >, MooseVariableFE< VectorValue< Real > >, MooseVariableFE< RealVectorValue >, MooseVariableFE< Real >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< T >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< Real >, MooseVariableField< OutputType >, MooseVariableField< RT >, MooseVariableField< ComputeValueType >, MooseVariableField< T >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< Real >, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< T >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< Real >, and Function.

Definition at line 831 of file MooseFunctor.h.

832 {
833  if (_clearance_schedule.count(EXEC_NONLINEAR))
834  clearCacheData();
835 }
EXEC_NONLINEAR
const ExecFlagType EXEC_NONLINEAR
Definition: Moose.C:33
Moose::FunctorBase::clearCacheData
void clearCacheData()
clear cache data
Definition: MooseFunctor.h:789
Moose::FunctorBase::_clearance_schedule
std::set< ExecFlagType > _clearance_schedule
How often to clear the material property cache.
Definition: MooseFunctor.h:514

◆ operator()() [1/6]

template<typename T >
FunctorBase< T >::ValueType Moose::FunctorBase< T >::operator() ( const ElemArg &  elem,
const StateArg &  state 
) const
inherited

Same as their evaluate overloads with the same arguments but allows for caching implementation.

These are the methods a user will call in their code

Definition at line 597 of file MooseFunctor.h.

598 {
599  if (_always_evaluate)
600  return evaluate(elem, state);
601 
602  mooseAssert(state.state == 0,
603  "Cached evaluations are only currently supported for the current state.");
604 
605  return queryFVArgCache(_elem_arg_to_value, elem);
606 }
Moose::FunctorBase::queryFVArgCache
ValueType queryFVArgCache(std::map< SpaceArg, ValueType > &cache_data, const SpaceArg &space) const
check a finite volume spatial argument cache and if invalid then evaluate
Definition: MooseFunctor.h:580
Moose::FunctorBase::evaluate
virtual ValueType evaluate(const ElemArg &elem, const StateArg &state) const =0
Evaluate the functor with a given element.
Moose::FunctorBase::_elem_arg_to_value
std::map< ElemArg, ValueType > _elem_arg_to_value
Map from element arguments to their cached evaluations.
Definition: MooseFunctor.h:555
Moose::FunctorBase::_always_evaluate
bool _always_evaluate
Boolean to check if we always need evaluation.
Definition: MooseFunctor.h:517

◆ operator()() [2/6]

template<typename T >
FunctorBase< T >::ValueType Moose::FunctorBase< T >::operator() ( const FaceArg &  face,
const StateArg &  state 
) const
inherited

Definition at line 610 of file MooseFunctor.h.

611 {
612  checkFace(face_in);
613 
614  if (_always_evaluate)
615  return evaluate(face_in, state);
616 
617  mooseAssert(state.state == 0,
618  "Cached evaluations are only currently supported for the current state.");
619 
620  return queryFVArgCache(_face_arg_to_value, face_in);
621 }
Moose::FunctorBase::_face_arg_to_value
std::map< FaceArg, ValueType > _face_arg_to_value
Map from face arguments to their cached evaluations.
Definition: MooseFunctor.h:558
Moose::FunctorBase::checkFace
void checkFace(const Moose::FaceArg &face) const
Examines the incoming face argument.
Definition: MooseFunctor.h:732
Moose::FunctorBase::queryFVArgCache
ValueType queryFVArgCache(std::map< SpaceArg, ValueType > &cache_data, const SpaceArg &space) const
check a finite volume spatial argument cache and if invalid then evaluate
Definition: MooseFunctor.h:580
Moose::FunctorBase::evaluate
virtual ValueType evaluate(const ElemArg &elem, const StateArg &state) const =0
Evaluate the functor with a given element.
Moose::FunctorBase::_always_evaluate
bool _always_evaluate
Boolean to check if we always need evaluation.
Definition: MooseFunctor.h:517

◆ operator()() [3/6]

template<typename T >
FunctorBase< T >::ValueType Moose::FunctorBase< T >::operator() ( const ElemQpArg &  qp,
const StateArg &  state 
) const
inherited

Definition at line 656 of file MooseFunctor.h.

657 {
658  if (_always_evaluate)
659  return evaluate(elem_qp, state);
660 
661  const auto elem_id = elem_qp.elem->id();
662  if (elem_id != _current_qp_map_key)
663  {
664  _current_qp_map_key = elem_id;
665  _current_qp_map_value = &_qp_to_value[elem_id];
666  }
667  auto & qp_data = *_current_qp_map_value;
668  const auto qp = elem_qp.qp;
669  const auto * const qrule = elem_qp.qrule;
670  mooseAssert(qrule, "qrule must be non-null");
671 
672  return queryQpCache(qp, *qrule, qp_data, elem_qp, state);
673 }
Moose::FunctorBase::_current_qp_map_key
dof_id_type _current_qp_map_key
Current key for qp map cache.
Definition: MooseFunctor.h:523
Moose::FunctorBase::_current_qp_map_value
std::vector< std::pair< bool, ValueType > > * _current_qp_map_value
Current value for qp map cache.
Definition: MooseFunctor.h:526
Moose::FunctorBase::queryQpCache
ValueType queryQpCache(unsigned int qp, const libMesh::QBase &qrule, std::vector< std::pair< bool, T >> &qp_cache_data, const SpaceArg &space, const StateArg &state) const
check a qp cache and if invalid then evaluate
Definition: MooseFunctor.h:626
Moose::FunctorBase::evaluate
virtual ValueType evaluate(const ElemArg &elem, const StateArg &state) const =0
Evaluate the functor with a given element.
Moose::FunctorBase::_always_evaluate
bool _always_evaluate
Boolean to check if we always need evaluation.
Definition: MooseFunctor.h:517
Moose::FunctorBase::_qp_to_value
std::unordered_map< dof_id_type, std::vector< std::pair< bool, ValueType > > > _qp_to_value
Cached element quadrature point functor property evaluations.
Definition: MooseFunctor.h:533

◆ operator()() [4/6]

template<typename T >
FunctorBase< T >::ValueType Moose::FunctorBase< T >::operator() ( const ElemSideQpArg &  qp,
const StateArg &  state 
) const
inherited

Definition at line 677 of file MooseFunctor.h.

678 {
679  if (_always_evaluate)
680  return evaluate(elem_side_qp, state);
681 
682  const Elem * const elem = elem_side_qp.elem;
683  mooseAssert(elem, "elem must be non-null");
684  const auto elem_id = elem->id();
685  if (elem_id != _current_side_qp_map_key)
686  {
687  _current_side_qp_map_key = elem_id;
688  _current_side_qp_map_value = &_side_qp_to_value[elem_id];
689  }
690  auto & side_qp_data = *_current_side_qp_map_value;
691  const auto side = elem_side_qp.side;
692  const auto qp = elem_side_qp.qp;
693  const auto * const qrule = elem_side_qp.qrule;
694  mooseAssert(qrule, "qrule must be non-null");
695 
696  // Check and see whether we even have sized for this side
697  if (side >= side_qp_data.size())
698  side_qp_data.resize(elem->n_sides());
699 
700  // Ok we were sized enough for our side
701  auto & qp_data = side_qp_data[side];
702  return queryQpCache(qp, *qrule, qp_data, elem_side_qp, state);
703 }
Moose::FunctorBase::_side_qp_to_value
std::unordered_map< dof_id_type, std::vector< std::vector< std::pair< bool, ValueType > > > > _side_qp_to_value
Cached element quadrature point functor property evaluations.
Definition: MooseFunctor.h:552
Moose::FunctorBase::queryQpCache
ValueType queryQpCache(unsigned int qp, const libMesh::QBase &qrule, std::vector< std::pair< bool, T >> &qp_cache_data, const SpaceArg &space, const StateArg &state) const
check a qp cache and if invalid then evaluate
Definition: MooseFunctor.h:626
Moose::FunctorBase::evaluate
virtual ValueType evaluate(const ElemArg &elem, const StateArg &state) const =0
Evaluate the functor with a given element.
Moose::FunctorBase::_current_side_qp_map_key
dof_id_type _current_side_qp_map_key
Current key for side-qp map cache.
Definition: MooseFunctor.h:539
Moose::FunctorBase::_current_side_qp_map_value
std::vector< std::vector< std::pair< bool, ValueType > > > * _current_side_qp_map_value
Current value for side-qp map cache.
Definition: MooseFunctor.h:542
Moose::FunctorBase::_always_evaluate
bool _always_evaluate
Boolean to check if we always need evaluation.
Definition: MooseFunctor.h:517

◆ operator()() [5/6]

template<typename T >
FunctorBase< T >::ValueType Moose::FunctorBase< T >::operator() ( const ElemPointArg &  elem_point,
const StateArg &  state 
) const
inherited

Definition at line 707 of file MooseFunctor.h.

708 {
709  return evaluate(elem_point, state);
710 }
Moose::FunctorBase::evaluate
virtual ValueType evaluate(const ElemArg &elem, const StateArg &state) const =0
Evaluate the functor with a given element.

◆ operator()() [6/6]

template<typename T >
FunctorBase< T >::ValueType Moose::FunctorBase< T >::operator() ( const NodeArg &  node,
const StateArg &  state 
) const
inherited

Definition at line 724 of file MooseFunctor.h.

725 {
726  mooseAssert(node.subdomain_ids, "Subdomain IDs must be supplied to the node argument");
727  return evaluate(node, state);
728 }
Moose::FunctorBase::evaluate
virtual ValueType evaluate(const ElemArg &elem, const StateArg &state) const =0
Evaluate the functor with a given element.

◆ residualSetup()

template<typename T >
void Moose::FunctorBase< T >::residualSetup ( )
overridevirtualinherited

Implements Moose::FunctorAbstract.

Reimplemented in MooseVariableFE< OutputType >, MooseVariableFE< ComputeValueType >, MooseVariableFE< T >, MooseVariableFE< RealEigenVector >, MooseVariableFE< VectorValue< Real > >, MooseVariableFE< RealVectorValue >, MooseVariableFE< Real >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< T >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< Real >, MooseVariableField< OutputType >, MooseVariableField< RT >, MooseVariableField< ComputeValueType >, MooseVariableField< T >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< Real >, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< T >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< Real >, and Function.

Definition at line 823 of file MooseFunctor.h.

824 {
825  if (_clearance_schedule.count(EXEC_LINEAR))
826  clearCacheData();
827 }
EXEC_LINEAR
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
Moose::FunctorBase::clearCacheData
void clearCacheData()
clear cache data
Definition: MooseFunctor.h:789
Moose::FunctorBase::_clearance_schedule
std::set< ExecFlagType > _clearance_schedule
How often to clear the material property cache.
Definition: MooseFunctor.h:514

◆ setCacheClearanceSchedule()

template<typename T >
void Moose::FunctorBase< T >::setCacheClearanceSchedule ( const std::set< ExecFlagType > &  clearance_schedule)
inherited

Set how often to clear the functor evaluation cache.

Definition at line 714 of file MooseFunctor.h.

715 {
716  if (clearance_schedule.count(EXEC_ALWAYS))
717  _always_evaluate = true;
718 
719  _clearance_schedule = clearance_schedule;
720 }
EXEC_ALWAYS
const ExecFlagType EXEC_ALWAYS
Definition: Moose.C:51
Moose::FunctorBase::_always_evaluate
bool _always_evaluate
Boolean to check if we always need evaluation.
Definition: MooseFunctor.h:517
Moose::FunctorBase::_clearance_schedule
std::set< ExecFlagType > _clearance_schedule
How often to clear the material property cache.
Definition: MooseFunctor.h:514

◆ supportsElemSideQpArg()

template<typename T >
bool Moose::RawValueFunctor< T >::supportsElemSideQpArg ( ) const
inlinefinaloverridevirtual

Whether this functor supports evaluation with ElemSideQpArg.

Implements Moose::FunctorBase< T >.

Definition at line 44 of file RawValueFunctor.h.

44 { return _ad_functor.supportsElemSideQpArg(); }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156

◆ supportsFaceArg()

template<typename T >
bool Moose::RawValueFunctor< T >::supportsFaceArg ( ) const
inlinefinaloverridevirtual

Whether this functor supports evaluation with FaceArg.

Implements Moose::FunctorBase< T >.

Definition at line 43 of file RawValueFunctor.h.

43 { return _ad_functor.supportsFaceArg(); }
Moose::RawValueFunctor::_ad_functor
const FunctorBase< typename ADType< T >::type > & _ad_functor
Our wrapped AD object.
Definition: RawValueFunctor.h:156

◆ timestepSetup()

template<typename T >
void Moose::FunctorBase< T >::timestepSetup ( )
overridevirtualinherited

Implements Moose::FunctorAbstract.

Reimplemented in MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< T >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< Real >, MooseVariableField< OutputType >, MooseVariableField< RT >, MooseVariableField< ComputeValueType >, MooseVariableField< T >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< Real >, Function, NumNonlinearIterations, and MemoryUsage.

Definition at line 815 of file MooseFunctor.h.

816 {
817  if (_clearance_schedule.count(EXEC_TIMESTEP_BEGIN))
818  clearCacheData();
819 }
EXEC_TIMESTEP_BEGIN
const ExecFlagType EXEC_TIMESTEP_BEGIN
Definition: Moose.C:37
Moose::FunctorBase::clearCacheData
void clearCacheData()
clear cache data
Definition: MooseFunctor.h:789
Moose::FunctorBase::_clearance_schedule
std::set< ExecFlagType > _clearance_schedule
How often to clear the material property cache.
Definition: MooseFunctor.h:514

Member Data Documentation

◆ _ad_functor

template<typename T >
const FunctorBase<typename ADType<T>::type>& Moose::RawValueFunctor< T >::_ad_functor
private

Our wrapped AD object.

Definition at line 156 of file RawValueFunctor.h.

Referenced by Moose::RawValueFunctor< T >::evaluate(), Moose::RawValueFunctor< T >::evaluateDot(), Moose::RawValueFunctor< T >::evaluateGradDot(), Moose::RawValueFunctor< T >::evaluateGradient(), Moose::RawValueFunctor< T >::hasBlocks(), Moose::RawValueFunctor< T >::hasFaceSide(), Moose::RawValueFunctor< T >::isConstant(), Moose::RawValueFunctor< T >::isExtrapolatedBoundaryFace(), Moose::RawValueFunctor< T >::supportsElemSideQpArg(), and Moose::RawValueFunctor< T >::supportsFaceArg().

The documentation for this class was generated from the following file:
Generated on Thu Oct 23 2025 22:21:31 for https://mooseframework.inl.gov by   doxygen 1.8.14