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

Class template for creating constant functors. More...

#include <MooseFunctor.h>

Inheritance diagram for Moose::ConstantFunctor< 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

 ConstantFunctor (const ValueType &value)
 
 ConstantFunctor (ValueType &&value)
 
virtual bool isConstant () const override
 Returns true if this functor is a constant. More...
 
bool hasBlocks (SubdomainID) const override
 Returns whether the functor is defined on this block. More...
 
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...
 
virtual bool isExtrapolatedBoundaryFace (const FaceInfo &, const Elem *, const StateArg &) const
 Returns whether this (sided) face is an extrapolated boundary face for this functor. More...
 
bool isInternalFace (const FaceInfo &) const
 Returns true if the face is an internal face. More...
 
virtual bool hasFaceSide (const FaceInfo &fi, const bool fi_elem_side) const override
 
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
 

Private Member Functions

ValueType evaluate (const ElemArg &, const StateArg &) const override
 Evaluate the functor with a given element. More...
 
ValueType evaluate (const FaceArg &, const StateArg &) const override
 
ValueType evaluate (const ElemQpArg &, const StateArg &) const override
 
ValueType evaluate (const ElemSideQpArg &, const StateArg &) const override
 
ValueType evaluate (const ElemPointArg &, const StateArg &) const override
 Evaluate the functor with a given element and point. More...
 
ValueType evaluate (const NodeArg &, const StateArg &) const override
 
GradientType evaluateGradient (const ElemArg &, const StateArg &) const override
 Evaluate the functor gradient with a given element. More...
 
GradientType evaluateGradient (const FaceArg &, const StateArg &) const override
 
GradientType evaluateGradient (const ElemQpArg &, const StateArg &) const override
 
GradientType evaluateGradient (const ElemSideQpArg &, const StateArg &) const override
 
GradientType evaluateGradient (const ElemPointArg &, const StateArg &) const override
 Evaluate the functor gradient with a given element and point. More...
 
GradientType evaluateGradient (const NodeArg &, const StateArg &) const override
 
DotType evaluateDot (const ElemArg &, const StateArg &) const override
 Evaluate the functor time derivative with a given element. More...
 
DotType evaluateDot (const FaceArg &, const StateArg &) const override
 
DotType evaluateDot (const ElemQpArg &, const StateArg &) const override
 
DotType evaluateDot (const ElemSideQpArg &, const StateArg &) const override
 
DotType evaluateDot (const ElemPointArg &, const StateArg &) const override
 Evaluate the functor time derivative with a given element and point. More...
 
DotType evaluateDot (const NodeArg &, const StateArg &) const override
 
GradientType evaluateGradDot (const ElemArg &, const StateArg &) const override
 Evaluate the functor gradient-dot with a given element. More...
 
GradientType evaluateGradDot (const FaceArg &, const StateArg &) const override
 
GradientType evaluateGradDot (const ElemQpArg &, const StateArg &) const override
 
GradientType evaluateGradDot (const ElemSideQpArg &, const StateArg &) const override
 
GradientType evaluateGradDot (const ElemPointArg &, const StateArg &) const override
 Evaluate the functor gradient-dot with a given element and point. More...
 
GradientType evaluateGradDot (const NodeArg &, const StateArg &) const override
 

Private Attributes

ValueType _value
 

Detailed Description

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

Class template for creating constant functors.

Definition at line 1273 of file MooseFunctor.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

◆ ConstantFunctor() [1/2]

template<typename T >
Moose::ConstantFunctor< T >::ConstantFunctor ( const ValueType &  value)
inline

Definition at line 1281 of file MooseFunctor.h.

1282  : FunctorBase<T>("constant_" + std::to_string(value)), _value(value)
1283  {
1284  }

◆ ConstantFunctor() [2/2]

template<typename T >
Moose::ConstantFunctor< T >::ConstantFunctor ( ValueType &&  value)
inline

Definition at line 1285 of file MooseFunctor.h.

1286  : FunctorBase<T>("constant_" + std::to_string(MetaPhysicL::raw_value(value))), _value(value)
1287  {
1288  }
MetaPhysicL::raw_value
auto raw_value(const Eigen::Map< T > &in)
Definition: EigenADReal.h:100

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 738 of file MooseFunctor.h.

743 {
744 #if DEBUG
745  const Elem * const elem = face.face_side;
746  const FaceInfo * const fi = face.fi;
747  mooseAssert(fi, "face info should be non-null");
748  bool check_elem_def = false;
749  bool check_neighbor_def = false;
750  // We check if the functor is defined on both sides of the face
751  if (!elem)
752  {
753  if (!hasFaceSide(*fi, true))
754  check_neighbor_def = true;
755  else if (!hasFaceSide(*fi, false))
756  check_elem_def = true;
757  }
758  else if (elem == fi->elemPtr())
759  check_elem_def = true;
760  else
761  {
762  mooseAssert(elem == fi->neighborPtr(), "This has to match something");
763  check_neighbor_def = true;
764  }
765 
766  if (check_elem_def && !hasFaceSide(*fi, true))
767  {
768  std::string additional_message = "It is not defined on the neighbor side either.";
769  if (hasFaceSide(*fi, false))
770  additional_message = "It is however defined on the neighbor side.";
771  additional_message += " Face centroid: " + Moose::stringify(fi->faceCentroid());
772  mooseError(_functor_name,
773  " is not defined on the element side of the face information, but a face argument "
774  "producer "
775  "(e.g. residual object, postprocessor, etc.) has requested evaluation there.\n",
776  additional_message);
777  }
778  if (check_neighbor_def && !hasFaceSide(*fi, false))
779  {
780  std::string additional_message = "It is not defined on the element side either.";
781  if (hasFaceSide(*fi, true))
782  additional_message = "It is however defined on the element side.";
783  additional_message += " Face centroid: " + Moose::stringify(fi->faceCentroid());
784  mooseError(
785  _functor_name,
786  " is not defined on the neighbor side of the face information, but a face argument "
787  "producer (e.g. residual object, postprocessor, etc.) has requested evaluation there.\n",
788  additional_message);
789  }
790 #endif
791 }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:311
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:75
FaceInfo
This data structure is used to store geometric and variable related metadata about each cell face in ...
Definition: FaceInfo.h:37
FaceInfo::neighborPtr
const Elem * neighborPtr() const
Definition: FaceInfo.h:88
Moose::FunctorBase::_functor_name
MooseFunctorName _functor_name
name of the functor
Definition: MooseFunctor.h:570
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:86
Moose::FunctorBase::hasFaceSide
virtual bool hasFaceSide(const FaceInfo &fi, const bool fi_elem_side) const override
Definition: MooseFunctor.h:982

◆ customSetup()

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

Implements Moose::FunctorAbstract.

Reimplemented in Function.

Definition at line 845 of file MooseFunctor.h.

846 {
847  if (_clearance_schedule.count(exec_type))
848  clearCacheData();
849 }
Moose::FunctorBase::clearCacheData
void clearCacheData()
clear cache data
Definition: MooseFunctor.h:795
Moose::FunctorBase::_clearance_schedule
std::set< ExecFlagType > _clearance_schedule
How often to clear the material property cache.
Definition: MooseFunctor.h:520

◆ 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 896 of file MooseFunctor.h.

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

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

◆ dot() [2/6]

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

Definition at line 903 of file MooseFunctor.h.

904 {
905  checkFace(face);
906  return evaluateDot(face, state);
907 }
Moose::FunctorBase::evaluateDot
virtual DotType evaluateDot(const ElemArg &, const StateArg &) const
Evaluate the functor time derivative with a given element.
Definition: MooseFunctor.h:391
Moose::FunctorBase::checkFace
void checkFace(const Moose::FaceArg &face) const
Examines the incoming face argument.
Definition: MooseFunctor.h:738

◆ dot() [3/6]

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

Definition at line 911 of file MooseFunctor.h.

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

◆ dot() [4/6]

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

Definition at line 918 of file MooseFunctor.h.

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

◆ 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 925 of file MooseFunctor.h.

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

◆ dot() [6/6]

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

Definition at line 932 of file MooseFunctor.h.

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

◆ evaluate() [1/6]

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

Evaluate the functor with a given element.

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

Implements Moose::FunctorBase< T >.

Definition at line 1298 of file MooseFunctor.h.

1298 { return _value; }

◆ evaluate() [2/6]

template<typename T >
ValueType Moose::ConstantFunctor< T >::evaluate ( const FaceArg &  face,
const StateArg &  state 
) const
inlineoverrideprivatevirtual
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 1299 of file MooseFunctor.h.

1299 { return _value; }

◆ evaluate() [3/6]

template<typename T >
ValueType Moose::ConstantFunctor< T >::evaluate ( const ElemQpArg &  qp,
const StateArg &  state 
) const
inlineoverrideprivatevirtual
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 1300 of file MooseFunctor.h.

1300 { return _value; }

◆ evaluate() [4/6]

template<typename T >
ValueType Moose::ConstantFunctor< T >::evaluate ( const ElemSideQpArg &  side_qp,
const StateArg &  state 
) const
inlineoverrideprivatevirtual
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 1301 of file MooseFunctor.h.

1301 { return _value; }

◆ evaluate() [5/6]

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

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 1302 of file MooseFunctor.h.

1302 { return _value; }

◆ evaluate() [6/6]

template<typename T >
ValueType Moose::ConstantFunctor< T >::evaluate ( const NodeArg &  ,
const StateArg &   
) const
inlineoverrideprivatevirtual

Implements Moose::FunctorBase< T >.

Definition at line 1303 of file MooseFunctor.h.

1303 { return _value; }

◆ evaluateDot() [1/6]

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

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 1315 of file MooseFunctor.h.

1315 { return 0; }

◆ evaluateDot() [2/6]

template<typename T >
DotType Moose::ConstantFunctor< T >::evaluateDot ( const FaceArg &  ,
const StateArg &   
) const
inlineoverrideprivatevirtual
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 1316 of file MooseFunctor.h.

1316 { return 0; }

◆ evaluateDot() [3/6]

template<typename T >
DotType Moose::ConstantFunctor< T >::evaluateDot ( const ElemQpArg &  ,
const StateArg &   
) const
inlineoverrideprivatevirtual
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 1317 of file MooseFunctor.h.

1317 { return 0; }

◆ evaluateDot() [4/6]

template<typename T >
DotType Moose::ConstantFunctor< T >::evaluateDot ( const ElemSideQpArg &  ,
const StateArg &   
) const
inlineoverrideprivatevirtual
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 1318 of file MooseFunctor.h.

1318 { return 0; }

◆ evaluateDot() [5/6]

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

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

Reimplemented from Moose::FunctorBase< T >.

Definition at line 1319 of file MooseFunctor.h.

1319 { return 0; }

◆ evaluateDot() [6/6]

template<typename T >
DotType Moose::ConstantFunctor< T >::evaluateDot ( const NodeArg &  ,
const StateArg &   
) const
inlineoverrideprivatevirtual

Reimplemented from Moose::FunctorBase< T >.

Definition at line 1320 of file MooseFunctor.h.

1320 { return 0; }

◆ evaluateGradDot() [1/6]

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

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 1322 of file MooseFunctor.h.

1322 { return 0; }

◆ evaluateGradDot() [2/6]

template<typename T >
GradientType Moose::ConstantFunctor< T >::evaluateGradDot ( const FaceArg &  ,
const StateArg &   
) const
inlineoverrideprivatevirtual
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 1323 of file MooseFunctor.h.

1323 { return 0; }

◆ evaluateGradDot() [3/6]

template<typename T >
GradientType Moose::ConstantFunctor< T >::evaluateGradDot ( const ElemQpArg &  ,
const StateArg &   
) const
inlineoverrideprivatevirtual
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 1324 of file MooseFunctor.h.

1324 { return 0; }

◆ evaluateGradDot() [4/6]

template<typename T >
GradientType Moose::ConstantFunctor< T >::evaluateGradDot ( const ElemSideQpArg &  ,
const StateArg &   
) const
inlineoverrideprivatevirtual
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 1325 of file MooseFunctor.h.

1325 { return 0; }

◆ evaluateGradDot() [5/6]

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

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

Reimplemented from Moose::FunctorBase< T >.

Definition at line 1326 of file MooseFunctor.h.

1326 { return 0; }

◆ evaluateGradDot() [6/6]

template<typename T >
GradientType Moose::ConstantFunctor< T >::evaluateGradDot ( const NodeArg &  ,
const StateArg &   
) const
inlineoverrideprivatevirtual

Reimplemented from Moose::FunctorBase< T >.

Definition at line 1327 of file MooseFunctor.h.

1327 { return 0; }

◆ evaluateGradient() [1/6]

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

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 1305 of file MooseFunctor.h.

1305 { return 0; }

◆ evaluateGradient() [2/6]

template<typename T >
GradientType Moose::ConstantFunctor< T >::evaluateGradient ( const FaceArg &  ,
const StateArg &   
) const
inlineoverrideprivatevirtual
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 1306 of file MooseFunctor.h.

1306 { return 0; }

◆ evaluateGradient() [3/6]

template<typename T >
GradientType Moose::ConstantFunctor< T >::evaluateGradient ( const ElemQpArg &  ,
const StateArg &   
) const
inlineoverrideprivatevirtual
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 1307 of file MooseFunctor.h.

1307 { return 0; }

◆ evaluateGradient() [4/6]

template<typename T >
GradientType Moose::ConstantFunctor< T >::evaluateGradient ( const ElemSideQpArg &  ,
const StateArg &   
) const
inlineoverrideprivatevirtual
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 1308 of file MooseFunctor.h.

1309  {
1310  return 0;
1311  }

◆ evaluateGradient() [5/6]

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

Evaluate the functor gradient with a given element and point.

Reimplemented from Moose::FunctorBase< T >.

Definition at line 1312 of file MooseFunctor.h.

1312 { return 0; }

◆ evaluateGradient() [6/6]

template<typename T >
GradientType Moose::ConstantFunctor< T >::evaluateGradient ( const NodeArg &  ,
const StateArg &   
) const
inlineoverrideprivatevirtual

Reimplemented from Moose::FunctorBase< T >.

Definition at line 1313 of file MooseFunctor.h.

1313 { return 0; }

◆ functorName()

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

Return the functor name.

Definition at line 176 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().

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

◆ 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 993 of file MooseFunctor.h.

994 {
995  if constexpr (FET == FunctorEvaluationKind::Value)
996  return (*this)(r, state);
997  else if constexpr (FET == FunctorEvaluationKind::Gradient)
998  return gradient(r, state);
999  else if constexpr (FET == FunctorEvaluationKind::Dot)
1000  return dot(r, state);
1001  else
1002  return gradDot(r, state);
1003 }
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:939
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:896
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:853

◆ 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 939 of file MooseFunctor.h.

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

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

◆ gradDot() [2/6]

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

Definition at line 946 of file MooseFunctor.h.

947 {
948  checkFace(face);
949  return evaluateGradDot(face, state);
950 }
Moose::FunctorBase::checkFace
void checkFace(const Moose::FaceArg &face) const
Examines the incoming face argument.
Definition: MooseFunctor.h:738
Moose::FunctorBase::evaluateGradDot
virtual GradientType evaluateGradDot(const ElemArg &, const StateArg &) const
Evaluate the functor gradient-dot with a given element.
Definition: MooseFunctor.h:445

◆ gradDot() [3/6]

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

Definition at line 954 of file MooseFunctor.h.

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

◆ gradDot() [4/6]

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

Definition at line 961 of file MooseFunctor.h.

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

◆ 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 968 of file MooseFunctor.h.

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

◆ gradDot() [6/6]

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

Definition at line 975 of file MooseFunctor.h.

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

◆ 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 853 of file MooseFunctor.h.

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

854 {
855  return evaluateGradient(elem, state);
856 }
Moose::FunctorBase::evaluateGradient
virtual GradientType evaluateGradient(const ElemArg &, const StateArg &) const
Evaluate the functor gradient with a given element.
Definition: MooseFunctor.h:338

◆ gradient() [2/6]

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

Definition at line 860 of file MooseFunctor.h.

861 {
862  checkFace(face);
863  return evaluateGradient(face, state);
864 }
Moose::FunctorBase::checkFace
void checkFace(const Moose::FaceArg &face) const
Examines the incoming face argument.
Definition: MooseFunctor.h:738
Moose::FunctorBase::evaluateGradient
virtual GradientType evaluateGradient(const ElemArg &, const StateArg &) const
Evaluate the functor gradient with a given element.
Definition: MooseFunctor.h:338

◆ gradient() [3/6]

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

Definition at line 868 of file MooseFunctor.h.

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

◆ gradient() [4/6]

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

Definition at line 875 of file MooseFunctor.h.

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

◆ 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 882 of file MooseFunctor.h.

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

◆ gradient() [6/6]

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

Definition at line 889 of file MooseFunctor.h.

890 {
891  return evaluateGradient(node, state);
892 }
Moose::FunctorBase::evaluateGradient
virtual GradientType evaluateGradient(const ElemArg &, const StateArg &) const
Evaluate the functor gradient with a given element.
Definition: MooseFunctor.h:338

◆ hasBlocks()

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

Returns whether the functor is defined on this block.

Reimplemented from Moose::FunctorBase< T >.

Definition at line 1292 of file MooseFunctor.h.

1292 { return true; }

◆ hasFaceSide()

template<typename T >
bool Moose::FunctorBase< T >::hasFaceSide ( const FaceInfo &  fi,
const bool  fi_elem_side 
) const
overridevirtualinherited

Implements FaceArgInterface.

Reimplemented in Moose::NullFunctor< T >, Moose::FunctorEnvelope< T >, Moose::FunctorEnvelope< ADReal >, Moose::FunctorEnvelope< GenericReal< is_ad > >, Moose::FunctorEnvelope< GenericRealVectorValue< is_ad > >, Moose::FunctorEnvelope< VectorValue< Real > >, Moose::FunctorEnvelope< Moose::GenericType< T, is_ad > >, Moose::FunctorEnvelope< VectorValue< GenericReal< is_ad > > >, Moose::FunctorEnvelope< Moose::GenericType< Real, is_ad > >, Moose::FunctorEnvelope< Real >, Moose::FunctorEnvelope< libMesh::VectorValue >, Moose::ADWrapperFunctor< T >, Moose::RawValueFunctor< T >, InternalSideIntegralVariablePostprocessor, InterfaceIntegralVariableValuePostprocessor, SideIntegralVariablePostprocessor, SideIntegralFunctorPostprocessorTempl< is_ad >, and SideIntegralFunctorPostprocessorTempl< false >.

Definition at line 982 of file MooseFunctor.h.

Referenced by SideIntegralVariablePostprocessor::hasFaceSide(), InternalSideIntegralVariablePostprocessor::hasFaceSide(), and Moose::ADWrapperFunctor< T >::hasFaceSide().

983 {
984  if (fi_elem_side)
985  return hasBlocks(fi.elem().subdomain_id());
986  else
987  return fi.neighborPtr() && hasBlocks(fi.neighbor().subdomain_id());
988 }
Moose::FunctorBase::hasBlocks
virtual bool hasBlocks(SubdomainID) const
Returns whether the functor is defined on this block.
Definition: MooseFunctor.h:243
FaceInfo::elem
const Elem & elem() const
Definition: FaceInfo.h:85
FaceInfo::neighborPtr
const Elem * neighborPtr() const
Definition: FaceInfo.h:88
FaceInfo::neighbor
const Elem & neighbor() const
Definition: FaceInfo.h:220

◆ isConstant()

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

Returns true if this functor is a constant.

Reimplemented from Moose::FunctorBase< T >.

Definition at line 1290 of file MooseFunctor.h.

1290 { return true; }

◆ isExtrapolatedBoundaryFace()

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

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

Reimplemented in Moose::FunctorEnvelope< T >, Moose::FunctorEnvelope< ADReal >, Moose::FunctorEnvelope< GenericReal< is_ad > >, Moose::FunctorEnvelope< GenericRealVectorValue< is_ad > >, Moose::FunctorEnvelope< VectorValue< Real > >, Moose::FunctorEnvelope< Moose::GenericType< T, is_ad > >, Moose::FunctorEnvelope< VectorValue< GenericReal< is_ad > > >, Moose::FunctorEnvelope< Moose::GenericType< Real, is_ad > >, Moose::FunctorEnvelope< Real >, Moose::FunctorEnvelope< libMesh::VectorValue >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< T >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< Real >, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< T >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< Real >, PiecewiseByBlockLambdaFunctor< T >, Moose::VectorComponentFunctor< T >, Moose::ArrayComponentFunctor< T, ArrayTypeFunctor >, Moose::ADWrapperFunctor< T >, and Moose::RawValueFunctor< T >.

Definition at line 253 of file MooseFunctor.h.

Referenced by Moose::ADWrapperFunctor< T >::isExtrapolatedBoundaryFace().

254  {
255  mooseError("not implemented");
256  }
mooseError
void mooseError(Args &&... args)
Emit an error message with the given stringified, concatenated args and terminate the application...
Definition: MooseError.h:311

◆ 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 575 of file MooseFunctor.h.

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

576 {
577  if (!fi.neighborPtr())
578  return false;
579 
580  return hasBlocks(fi.elem().subdomain_id()) && hasBlocks(fi.neighborPtr()->subdomain_id());
581 }
Moose::FunctorBase::hasBlocks
virtual bool hasBlocks(SubdomainID) const
Returns whether the functor is defined on this block.
Definition: MooseFunctor.h:243
FaceInfo::elem
const Elem & elem() const
Definition: FaceInfo.h:85
FaceInfo::neighborPtr
const Elem * neighborPtr() const
Definition: FaceInfo.h:88

◆ 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 837 of file MooseFunctor.h.

838 {
839  if (_clearance_schedule.count(EXEC_NONLINEAR))
840  clearCacheData();
841 }
EXEC_NONLINEAR
const ExecFlagType EXEC_NONLINEAR
Definition: Moose.C:33
Moose::FunctorBase::clearCacheData
void clearCacheData()
clear cache data
Definition: MooseFunctor.h:795
Moose::FunctorBase::_clearance_schedule
std::set< ExecFlagType > _clearance_schedule
How often to clear the material property cache.
Definition: MooseFunctor.h:520

◆ 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 603 of file MooseFunctor.h.

604 {
605  if (_always_evaluate)
606  return evaluate(elem, state);
607 
608  mooseAssert(state.state == 0,
609  "Cached evaluations are only currently supported for the current state.");
610 
611  return queryFVArgCache(_elem_arg_to_value, elem);
612 }
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:586
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:561
Moose::FunctorBase::_always_evaluate
bool _always_evaluate
Boolean to check if we always need evaluation.
Definition: MooseFunctor.h:523

◆ operator()() [2/6]

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

Definition at line 616 of file MooseFunctor.h.

617 {
618  checkFace(face_in);
619 
620  if (_always_evaluate)
621  return evaluate(face_in, state);
622 
623  mooseAssert(state.state == 0,
624  "Cached evaluations are only currently supported for the current state.");
625 
626  return queryFVArgCache(_face_arg_to_value, face_in);
627 }
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:564
Moose::FunctorBase::checkFace
void checkFace(const Moose::FaceArg &face) const
Examines the incoming face argument.
Definition: MooseFunctor.h:738
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:586
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:523

◆ operator()() [3/6]

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

Definition at line 662 of file MooseFunctor.h.

663 {
664  if (_always_evaluate)
665  return evaluate(elem_qp, state);
666 
667  const auto elem_id = elem_qp.elem->id();
668  if (elem_id != _current_qp_map_key)
669  {
670  _current_qp_map_key = elem_id;
671  _current_qp_map_value = &_qp_to_value[elem_id];
672  }
673  auto & qp_data = *_current_qp_map_value;
674  const auto qp = elem_qp.qp;
675  const auto * const qrule = elem_qp.qrule;
676  mooseAssert(qrule, "qrule must be non-null");
677 
678  return queryQpCache(qp, *qrule, qp_data, elem_qp, state);
679 }
Moose::FunctorBase::_current_qp_map_key
dof_id_type _current_qp_map_key
Current key for qp map cache.
Definition: MooseFunctor.h:529
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:532
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:632
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:523
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:539

◆ operator()() [4/6]

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

Definition at line 683 of file MooseFunctor.h.

684 {
685  if (_always_evaluate)
686  return evaluate(elem_side_qp, state);
687 
688  const Elem * const elem = elem_side_qp.elem;
689  mooseAssert(elem, "elem must be non-null");
690  const auto elem_id = elem->id();
691  if (elem_id != _current_side_qp_map_key)
692  {
693  _current_side_qp_map_key = elem_id;
694  _current_side_qp_map_value = &_side_qp_to_value[elem_id];
695  }
696  auto & side_qp_data = *_current_side_qp_map_value;
697  const auto side = elem_side_qp.side;
698  const auto qp = elem_side_qp.qp;
699  const auto * const qrule = elem_side_qp.qrule;
700  mooseAssert(qrule, "qrule must be non-null");
701 
702  // Check and see whether we even have sized for this side
703  if (side >= side_qp_data.size())
704  side_qp_data.resize(elem->n_sides());
705 
706  // Ok we were sized enough for our side
707  auto & qp_data = side_qp_data[side];
708  return queryQpCache(qp, *qrule, qp_data, elem_side_qp, state);
709 }
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:558
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:632
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:545
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:548
Moose::FunctorBase::_always_evaluate
bool _always_evaluate
Boolean to check if we always need evaluation.
Definition: MooseFunctor.h:523

◆ 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 713 of file MooseFunctor.h.

714 {
715  return evaluate(elem_point, state);
716 }
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 730 of file MooseFunctor.h.

731 {
732  mooseAssert(node.subdomain_ids, "Subdomain IDs must be supplied to the node argument");
733  return evaluate(node, state);
734 }
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 829 of file MooseFunctor.h.

830 {
831  if (_clearance_schedule.count(EXEC_LINEAR))
832  clearCacheData();
833 }
EXEC_LINEAR
const ExecFlagType EXEC_LINEAR
Definition: Moose.C:31
Moose::FunctorBase::clearCacheData
void clearCacheData()
clear cache data
Definition: MooseFunctor.h:795
Moose::FunctorBase::_clearance_schedule
std::set< ExecFlagType > _clearance_schedule
How often to clear the material property cache.
Definition: MooseFunctor.h:520

◆ 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 720 of file MooseFunctor.h.

721 {
722  if (clearance_schedule.count(EXEC_ALWAYS))
723  _always_evaluate = true;
724 
725  _clearance_schedule = clearance_schedule;
726 }
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:523
Moose::FunctorBase::_clearance_schedule
std::set< ExecFlagType > _clearance_schedule
How often to clear the material property cache.
Definition: MooseFunctor.h:520

◆ supportsElemSideQpArg()

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

Whether this functor supports evaluation with ElemSideQpArg.

Implements Moose::FunctorBase< T >.

Definition at line 1295 of file MooseFunctor.h.

1295 { return true; }

◆ supportsFaceArg()

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

Whether this functor supports evaluation with FaceArg.

Implements Moose::FunctorBase< T >.

Definition at line 1294 of file MooseFunctor.h.

1294 { return true; }

◆ 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 >, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< T >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< Real >, Function, NumNonlinearIterations, and MemoryUsage.

Definition at line 821 of file MooseFunctor.h.

822 {
823  if (_clearance_schedule.count(EXEC_TIMESTEP_BEGIN))
824  clearCacheData();
825 }
EXEC_TIMESTEP_BEGIN
const ExecFlagType EXEC_TIMESTEP_BEGIN
Definition: Moose.C:37
Moose::FunctorBase::clearCacheData
void clearCacheData()
clear cache data
Definition: MooseFunctor.h:795
Moose::FunctorBase::_clearance_schedule
std::set< ExecFlagType > _clearance_schedule
How often to clear the material property cache.
Definition: MooseFunctor.h:520

Member Data Documentation

◆ _value

template<typename T >
ValueType Moose::ConstantFunctor< T >::_value
private

Definition at line 1330 of file MooseFunctor.h.

Referenced by Moose::ConstantFunctor< T >::evaluate().

The documentation for this class was generated from the following file:
Generated on Wed Jun 24 2026 08:16:47 for https://mooseframework.inl.gov by   doxygen 1.8.14