Base class template for functor objects. More...

#include <MooseFunctor.h>

Inheritance diagram for Moose::FunctorBase< T >:

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
virtual	~FunctorBase ()=default

	FunctorBase (const MooseFunctorName &name, const std::set< ExecFlagType > &clearance_schedule={EXEC_ALWAYS})

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	hasBlocks (SubdomainID) const
	Returns whether the functor is defined on this block. 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	isConstant () const
	Returns true if this functor is a constant. 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...

virtual bool	supportsFaceArg () const =0
	Whether this functor supports evaluation with FaceArg. More...

virtual bool	supportsElemSideQpArg () const =0
	Whether this functor supports evaluation with ElemSideQpArg. 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
Functor evaluation routines
These methods are all for evaluating functors with different kinds of spatial arguments. Each of these methods also takes a state argument. For a description of the state argument, please see the `StateArg` doxygen
virtual ValueType	evaluate (const ElemArg &elem, const StateArg &state) const =0
	Evaluate the functor with a given element. More...

virtual ValueType	evaluate (const FaceArg &face, const StateArg &state) const =0

virtual ValueType	evaluate (const ElemQpArg &qp, const StateArg &state) const =0

virtual ValueType	evaluate (const ElemSideQpArg &side_qp, const StateArg &state) const =0

virtual ValueType	evaluate (const ElemPointArg &elem_point, const StateArg &state) const =0
	Evaluate the functor with a given element and point. More...

virtual ValueType	evaluate (const NodeArg &node, const StateArg &state) const =0

virtual GradientType	evaluateGradient (const ElemArg &, const StateArg &) const
	Evaluate the functor gradient with a given element. More...

virtual GradientType	evaluateGradient (const FaceArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const ElemQpArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const ElemSideQpArg &, const StateArg &) const

virtual GradientType	evaluateGradient (const ElemPointArg &, const StateArg &) const
	Evaluate the functor gradient with a given element and point. More...

virtual GradientType	evaluateGradient (const NodeArg &, const StateArg &) const

virtual DotType	evaluateDot (const ElemArg &, const StateArg &) const
	Evaluate the functor time derivative with a given element. More...

virtual DotType	evaluateDot (const FaceArg &, const StateArg &) const

virtual DotType	evaluateDot (const ElemQpArg &, const StateArg &) const

virtual DotType	evaluateDot (const ElemSideQpArg &, const StateArg &) const

virtual DotType	evaluateDot (const ElemPointArg &, const StateArg &) const
	Evaluate the functor time derivative with a given element and point. More...

virtual DotType	evaluateDot (const NodeArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemArg &, const StateArg &) const
	Evaluate the functor gradient-dot with a given element. More...

virtual GradientType	evaluateGradDot (const FaceArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemSideQpArg &, const StateArg &) const

virtual GradientType	evaluateGradDot (const ElemPointArg &, const StateArg &) const
	Evaluate the functor gradient-dot with a given element and point. More...

virtual GradientType	evaluateGradDot (const NodeArg &, const StateArg &) const

Private Member Functions
void	clearCacheData ()
	clear cache data More...

template<typename SpaceArg , typename StateArg >
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 More...

template<typename SpaceArg >
ValueType	queryFVArgCache (std::map< SpaceArg, ValueType > &cache_data, const SpaceArg &space) const
	check a finite volume spatial argument cache and if invalid then evaluate More...

Private Attributes
std::set< ExecFlagType >	_clearance_schedule
	How often to clear the material property cache. More...

bool	_always_evaluate
	Boolean to check if we always need evaluation. More...

dof_id_type	_current_qp_map_key = libMesh::DofObject::invalid_id
	Current key for qp map cache. More...

std::vector< std::pair< bool, ValueType > > *	_current_qp_map_value = nullptr
	Current value for qp map cache. More...

std::unordered_map< dof_id_type, std::vector< std::pair< bool, ValueType > > >	_qp_to_value
	Cached element quadrature point functor property evaluations. More...

dof_id_type	_current_side_qp_map_key = libMesh::DofObject::invalid_id
	Current key for side-qp map cache. More...

std::vector< std::vector< std::pair< bool, ValueType > > > *	_current_side_qp_map_value
	Current value for side-qp map cache. More...

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. More...

std::map< ElemArg, ValueType >	_elem_arg_to_value
	Map from element arguments to their cached evaluations. More...

std::map< FaceArg, ValueType >	_face_arg_to_value
	Map from face arguments to their cached evaluations. More...

std::map< NodeArg, ValueType >	_node_arg_to_value
	Map from nodal arguments to their cached evaluations. More...

MooseFunctorName	_functor_name
	name of the functor More...

Detailed Description

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

Base class template for functor objects.

This class template defines various operator() overloads that allow a user to evaluate the functor at arbitrary geometric locations. This template is meant to enable highly flexible on-the-fly variable and material property evaluations

Definition at line 137 of file MooseFunctor.h.

Member Typedef Documentation

◆ DotType

template<typename T>

using Moose::FunctorBase< T >::DotType = ValueType

Definition at line 150 of file MooseFunctor.h.

◆ FunctorType

template<typename T>

using Moose::FunctorBase< T >::FunctorType = FunctorBase<T>

Definition at line 140 of file MooseFunctor.h.

◆ GradientType

template<typename T>

using Moose::FunctorBase< T >::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).

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

Definition at line 141 of file MooseFunctor.h.

Constructor & Destructor Documentation

◆ ~FunctorBase()

template<typename T>

virtual Moose::FunctorBase< T >::~FunctorBase ( )

virtualdefault

◆ FunctorBase()

template<typename T>

Moose::FunctorBase< T >::FunctorBase	(	const MooseFunctorName &	name,
		const std::set< ExecFlagType > &	clearance_schedule = `{EXEC_ALWAYS}`
	)

inline

Definition at line 153 of file MooseFunctor.h.

                                                                 {EXEC_ALWAYS})
     : _always_evaluate(true), _functor_name(name)
 
   {
     setCacheClearanceSchedule(clearance_schedule);
   }

Member Function Documentation

◆ checkFace()

template<typename T>

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

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

face	The 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.

 {
 #if DEBUG
   const Elem * const elem = face.face_side;
   const FaceInfo * const fi = face.fi;
   mooseAssert(fi, "face info should be non-null");
   bool check_elem_def = false;
   bool check_neighbor_def = false;
   // We check if the functor is defined on both sides of the face
   if (!elem)
   {
     if (!hasFaceSide(*fi, true))
       check_neighbor_def = true;
     else if (!hasFaceSide(*fi, false))
       check_elem_def = true;
   }
   else if (elem == fi->elemPtr())
     check_elem_def = true;
   else
   {
     mooseAssert(elem == fi->neighborPtr(), "This has to match something");
     check_neighbor_def = true;
   }
 
   if (check_elem_def && !hasFaceSide(*fi, true))
   {
     std::string additional_message = "It is not defined on the neighbor side either.";
     if (hasFaceSide(*fi, false))
       additional_message = "It is however defined on the neighbor side.";
     additional_message += " Face centroid: " + Moose::stringify(fi->faceCentroid());
     mooseError(_functor_name,
                " is not defined on the element side of the face information, but a face argument "
                "producer "
                "(e.g. residual object, postprocessor, etc.) has requested evaluation there.\n",
                additional_message);
   }
   if (check_neighbor_def && !hasFaceSide(*fi, false))
   {
     std::string additional_message = "It is not defined on the element side either.";
     if (hasFaceSide(*fi, true))
       additional_message = "It is however defined on the element side.";
     additional_message += " Face centroid: " + Moose::stringify(fi->faceCentroid());
     mooseError(
         _functor_name,
         " is not defined on the neighbor side of the face information, but a face argument "
         "producer (e.g. residual object, postprocessor, etc.) has requested evaluation there.\n",
         additional_message);
   }
 #endif
 }

◆ clearCacheData()

template<typename T >

void Moose::FunctorBase< T >::clearCacheData ( )

private

clear cache data

Definition at line 789 of file MooseFunctor.h.

 {
   for (auto & map_pr : _qp_to_value)
     for (auto & pr : map_pr.second)
       pr.first = false;
 
   for (auto & map_pr : _side_qp_to_value)
   {
     auto & side_vector = map_pr.second;
     for (auto & qp_vector : side_vector)
       for (auto & pr : qp_vector)
         pr.first = false;
   }
 
   _current_qp_map_key = libMesh::DofObject::invalid_id;
   _current_qp_map_value = nullptr;
   _current_side_qp_map_key = libMesh::DofObject::invalid_id;
   _current_side_qp_map_value = nullptr;
 
   _elem_arg_to_value.clear();
   _face_arg_to_value.clear();
   _node_arg_to_value.clear();
 }

◆ customSetup()

template<typename T >

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

overridevirtual

Implements Moose::FunctorAbstract.

Reimplemented in Function.

Definition at line 839 of file MooseFunctor.h.

 {
   if (_clearance_schedule.count(exec_type))
     clearCacheData();
 }

◆ dot() [1/6]

template<typename T >

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

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().

 {
   return evaluateDot(elem, state);
 }

◆ dot() [2/6]

template<typename T >

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

Definition at line 897 of file MooseFunctor.h.

 {
   checkFace(face);
   return evaluateDot(face, state);
 }

◆ dot() [3/6]

template<typename T >

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

Definition at line 905 of file MooseFunctor.h.

 {
   return evaluateDot(elem_qp, state);
 }

◆ dot() [4/6]

template<typename T >

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

Definition at line 912 of file MooseFunctor.h.

 {
   return evaluateDot(elem_side_qp, state);
 }

◆ dot() [5/6]

template<typename T >

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

Definition at line 919 of file MooseFunctor.h.

 {
   return evaluateDot(elem_point, state);
 }

◆ dot() [6/6]

template<typename T >

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

Definition at line 926 of file MooseFunctor.h.

 {
   return evaluateDot(node, state);
 }

◆ evaluate() [1/6]

template<typename T>

virtual ValueType Moose::FunctorBase< T >::evaluate	(	const ElemArg &	elem,
		const StateArg &	state
	)		const

protectedpure virtual

Evaluate the functor with a given element.

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

◆ evaluate() [2/6]

template<typename T>

virtual ValueType Moose::FunctorBase< T >::evaluate	(	const FaceArg &	face,
		const StateArg &	state
	)		const

protectedpure virtual

Parameters

face	See the `FaceArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor evaluated at the requested state and space

◆ evaluate() [3/6]

template<typename T>

virtual ValueType Moose::FunctorBase< T >::evaluate	(	const ElemQpArg &	qp,
		const StateArg &	state
	)		const

protectedpure virtual

Parameters

qp	See the `ElemQpArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor evaluated at the requested state and space

◆ evaluate() [4/6]

template<typename T>

virtual ValueType Moose::FunctorBase< T >::evaluate	(	const ElemSideQpArg &	side_qp,
		const StateArg &	state
	)		const

protectedpure virtual

Parameters

side_qp	See the `ElemSideQpArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor evaluated at the requested state and space

◆ evaluate() [5/6]

template<typename T>

virtual ValueType Moose::FunctorBase< T >::evaluate	(	const ElemPointArg &	elem_point,
		const StateArg &	state
	)		const

protectedpure virtual

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

◆ evaluate() [6/6]

template<typename T>

virtual ValueType Moose::FunctorBase< T >::evaluate	(	const NodeArg &	node,
		const StateArg &	state
	)		const

protectedpure virtual

◆ evaluateDot() [1/6]

template<typename T>

virtual DotType Moose::FunctorBase< T >::evaluateDot	(	const ElemArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

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 in Moose::ConstantFunctor< 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 >, 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 >, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< T >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< Real >, Function, Postprocessor, Moose::ADWrapperFunctor< T >, Moose::RawValueFunctor< T >, and Moose::VectorCompositeFunctor< T >.

Definition at line 385 of file MooseFunctor.h.

   {
     mooseError("Element time derivative not implemented for functor " + functorName());
   }

◆ evaluateDot() [2/6]

template<typename T>

virtual DotType Moose::FunctorBase< T >::evaluateDot	(	const FaceArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

Parameters

face	See the `FaceArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor time derivative evaluated at the requested state and space

Definition at line 395 of file MooseFunctor.h.

   {
     mooseError("Face time derivative not implemented for functor " + functorName());
   }

◆ evaluateDot() [3/6]

template<typename T>

virtual DotType Moose::FunctorBase< T >::evaluateDot	(	const ElemQpArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

Parameters

qp	See the `ElemQpArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor time derivative evaluated at the requested state and space

Definition at line 405 of file MooseFunctor.h.

   {
     mooseError("Element quadrature point time derivative not implemented for functor " +
                functorName());
   }

◆ evaluateDot() [4/6]

template<typename T>

virtual DotType Moose::FunctorBase< T >::evaluateDot	(	const ElemSideQpArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

Parameters

side_qp	See the `ElemSideQpArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor time derivative evaluated at the requested state and space

Definition at line 416 of file MooseFunctor.h.

   {
     mooseError("Element side quadrature point time derivative not implemented for functor " +
                functorName());
   }

◆ evaluateDot() [5/6]

template<typename T>

virtual DotType Moose::FunctorBase< T >::evaluateDot	(	const ElemPointArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

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

Definition at line 425 of file MooseFunctor.h.

   {
     mooseError("Element-point time derivative not implemented for functor " + functorName());
   }

◆ evaluateDot() [6/6]

template<typename T>

virtual DotType Moose::FunctorBase< T >::evaluateDot	(	const NodeArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

Definition at line 430 of file MooseFunctor.h.

   {
     mooseError("Time derivative at node not implemented for functor " + functorName());
   }

◆ evaluateGradDot() [1/6]

template<typename T>

virtual GradientType Moose::FunctorBase< T >::evaluateGradDot	(	const ElemArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

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

Definition at line 439 of file MooseFunctor.h.

   {
     mooseError("Element gradient-dot not implemented for functor " + functorName());
   }

◆ evaluateGradDot() [2/6]

template<typename T>

virtual GradientType Moose::FunctorBase< T >::evaluateGradDot	(	const FaceArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

Parameters

face	See the `FaceArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor gradient-dot evaluated at the requested state and space

Definition at line 449 of file MooseFunctor.h.

   {
     mooseError("Face gradient-dot not implemented for functor " + functorName());
   }

◆ evaluateGradDot() [3/6]

template<typename T>

virtual GradientType Moose::FunctorBase< T >::evaluateGradDot	(	const ElemQpArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

Parameters

qp	See the `ElemQpArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor gradient-dot evaluated at the requested state and space

Definition at line 459 of file MooseFunctor.h.

   {
     mooseError("Element quadrature point gradient-dot not implemented for functor " +
                functorName());
   }

◆ evaluateGradDot() [4/6]

template<typename T>

virtual GradientType Moose::FunctorBase< T >::evaluateGradDot	(	const ElemSideQpArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

Parameters

side_qp	See the `ElemSideQpArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor gradient-dot evaluated at the requested state and space

Definition at line 470 of file MooseFunctor.h.

   {
     mooseError("Element side quadrature point gradient-dot not implemented for functor " +
                functorName());
   }

◆ evaluateGradDot() [5/6]

template<typename T>

virtual GradientType Moose::FunctorBase< T >::evaluateGradDot	(	const ElemPointArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

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

Definition at line 479 of file MooseFunctor.h.

   {
     mooseError("Element-point gradient-dot not implemented for functor " + functorName());
   }

◆ evaluateGradDot() [6/6]

template<typename T>

virtual GradientType Moose::FunctorBase< T >::evaluateGradDot	(	const NodeArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

Definition at line 484 of file MooseFunctor.h.

   {
     mooseError("Gradient-dot at node not implemented for functor " + functorName());
   }

◆ evaluateGradient() [1/6]

template<typename T>

virtual GradientType Moose::FunctorBase< T >::evaluateGradient	(	const ElemArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

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 in Moose::ConstantFunctor< 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 >, 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 >, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< T >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< Real >, Function, Postprocessor, PiecewiseByBlockLambdaFunctor< T >, Moose::ADWrapperFunctor< T >, Moose::VectorComponentFunctor< T >, Moose::ArrayComponentFunctor< T, ArrayTypeFunctor >, Moose::RawValueFunctor< T >, and Moose::VectorCompositeFunctor< T >.

Definition at line 332 of file MooseFunctor.h.

   {
     mooseError("Element gradient not implemented for functor " + functorName());
   }

◆ evaluateGradient() [2/6]

template<typename T>

virtual GradientType Moose::FunctorBase< T >::evaluateGradient	(	const FaceArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

Parameters

face	See the `FaceArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor gradient evaluated at the requested state and space

Definition at line 342 of file MooseFunctor.h.

   {
     mooseError("Face gradient not implemented for functor " + functorName());
   }

◆ evaluateGradient() [3/6]

template<typename T>

virtual GradientType Moose::FunctorBase< T >::evaluateGradient	(	const ElemQpArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

Parameters

qp	See the `ElemQpArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor gradient evaluated at the requested state and space

Reimplemented in Moose::ConstantFunctor< 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 >, 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 >, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< T >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< Real >, Function, Postprocessor, Moose::ADWrapperFunctor< T >, and Moose::RawValueFunctor< T >.

Definition at line 352 of file MooseFunctor.h.

   {
     mooseError("Element quadrature point gradient not implemented for functor " + functorName());
   }

◆ evaluateGradient() [4/6]

template<typename T>

virtual GradientType Moose::FunctorBase< T >::evaluateGradient	(	const ElemSideQpArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

Parameters

side_qp	See the `ElemSideQpArg` doxygen
state	See the `StateArg` doxygen

Returns: The functor gradient evaluated at the requested state and space

Definition at line 362 of file MooseFunctor.h.

   {
     mooseError("Element side quadrature point gradient not implemented for functor " +
                functorName());
   }

◆ evaluateGradient() [5/6]

template<typename T>

virtual GradientType Moose::FunctorBase< T >::evaluateGradient	(	const ElemPointArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

Evaluate the functor gradient with a given element and point.

Definition at line 371 of file MooseFunctor.h.

   {
     mooseError("Element-point gradient not implemented for functor " + functorName());
   }

◆ evaluateGradient() [6/6]

template<typename T>

virtual GradientType Moose::FunctorBase< T >::evaluateGradient	(	const NodeArg &	,
		const StateArg &
	)		const

inlineprotectedvirtual

Definition at line 376 of file MooseFunctor.h.

   {
     mooseError("Gradient at node not implemented for functor " + functorName());
   }

◆ functorName()

template<typename T>

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

inline

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

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.

 {
   if constexpr (FET == FunctorEvaluationKind::Value)
     return (*this)(r, state);
   else if constexpr (FET == FunctorEvaluationKind::Gradient)
     return gradient(r, state);
   else if constexpr (FET == FunctorEvaluationKind::Dot)
     return dot(r, state);
   else
     return gradDot(r, state);
 }

◆ gradDot() [1/6]

template<typename T >

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

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().

 {
   return evaluateGradDot(elem, state);
 }

◆ gradDot() [2/6]

template<typename T >

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

Definition at line 940 of file MooseFunctor.h.

 {
   checkFace(face);
   return evaluateGradDot(face, state);
 }

◆ gradDot() [3/6]

template<typename T >

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

Definition at line 948 of file MooseFunctor.h.

 {
   return evaluateGradDot(elem_qp, state);
 }

◆ gradDot() [4/6]

template<typename T >

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

Definition at line 955 of file MooseFunctor.h.

 {
   return evaluateGradDot(elem_side_qp, state);
 }

◆ gradDot() [5/6]

template<typename T >

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

Definition at line 962 of file MooseFunctor.h.

 {
   return evaluateGradDot(elem_point, state);
 }

◆ gradDot() [6/6]

template<typename T >

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

Definition at line 969 of file MooseFunctor.h.

 {
   return evaluateGradDot(node, state);
 }

◆ gradient() [1/6]

template<typename T >

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

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().

 {
   return evaluateGradient(elem, state);
 }

◆ gradient() [2/6]

template<typename T >

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

Definition at line 854 of file MooseFunctor.h.

 {
   checkFace(face);
   return evaluateGradient(face, state);
 }

◆ gradient() [3/6]

template<typename T >

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

Definition at line 862 of file MooseFunctor.h.

 {
   return evaluateGradient(elem_qp, state);
 }

◆ gradient() [4/6]

template<typename T >

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

Definition at line 869 of file MooseFunctor.h.

 {
   return evaluateGradient(elem_side_qp, state);
 }

◆ gradient() [5/6]

template<typename T >

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

Definition at line 876 of file MooseFunctor.h.

 {
   return evaluateGradient(elem_point, state);
 }

◆ gradient() [6/6]

template<typename T >

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

Definition at line 883 of file MooseFunctor.h.

 {
   return evaluateGradient(node, state);
 }

◆ hasBlocks()

template<typename T>

virtual bool Moose::FunctorBase< T >::hasBlocks ( SubdomainID ) const

inlinevirtual

Returns whether the functor is defined on this block.

Reimplemented in Moose::ConstantFunctor< 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 >, MooseVariableField< OutputType >, MooseVariableField< ComputeValueType >, MooseVariableField< RT >, MooseVariableField< T >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< Real >, Function, Postprocessor, PiecewiseByBlockLambdaFunctor< T >, Moose::VectorCompositeFunctor< T >, MeshDivisionFunctorReductionVectorPostprocessor, Moose::ADWrapperFunctor< T >, Moose::VectorComponentFunctor< T >, Moose::ArrayComponentFunctor< T, ArrayTypeFunctor >, Moose::RawValueFunctor< T >, SpatialUserObjectFunctor< UserObjectType >, SpatialUserObjectFunctor< PointVariableSamplerBase >, SpatialUserObjectFunctor< SideIntegralFunctorUserObject >, SpatialUserObjectFunctor< SideIntegralVariableUserObject >, SpatialUserObjectFunctor< GeneralUserObject >, SpatialUserObjectFunctor< ElementVectorPostprocessor >, SpatialUserObjectFunctor< FunctionElementIntegralUserObject >, SpatialUserObjectFunctor< ElementIntegralFunctorUserObject >, SpatialUserObjectFunctor< ElementVariableVectorPostprocessor >, SpatialUserObjectFunctor< BaseType >, and SpatialUserObjectFunctor< ElementIntegralVariableUserObject >.

Definition at line 237 of file MooseFunctor.h.

Referenced by Moose::FV::greenGaussGradient(), SpatialUserObjectFunctor< ElementIntegralVariableUserObject >::hasBlocks(), Moose::VectorComponentFunctor< T >::hasBlocks(), and Moose::ADWrapperFunctor< T >::hasBlocks().

   {
     mooseError("Block restriction has not been implemented for functor " + functorName());
     return false;
   }

◆ hasFaceSide()

template<typename T >

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

overridevirtual

Implements FaceArgInterface.

Definition at line 976 of file MooseFunctor.h.

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

 {
   if (fi_elem_side)
     return hasBlocks(fi.elem().subdomain_id());
   else
     return fi.neighborPtr() && hasBlocks(fi.neighbor().subdomain_id());
 }

◆ isConstant()

template<typename T>

virtual bool Moose::FunctorBase< T >::isConstant ( ) const

inlinevirtual

Returns true if this functor is a constant.

Definition at line 260 of file MooseFunctor.h.

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

260 { return false; }

◆ isExtrapolatedBoundaryFace()

template<typename T>

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

inlinevirtual

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

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

   {
     mooseError("not implemented");
   }

◆ isInternalFace()

template<typename T >

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

Returns true if the face is an internal face.

Definition at line 569 of file MooseFunctor.h.

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

 {
   if (!fi.neighborPtr())
     return false;
 
   return hasBlocks(fi.elem().subdomain_id()) && hasBlocks(fi.neighborPtr()->subdomain_id());
 }

◆ jacobianSetup()

template<typename T >

void Moose::FunctorBase< T >::jacobianSetup ( )

overridevirtual

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< ComputeValueType >, MooseVariableField< RT >, 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.

 {
   if (_clearance_schedule.count(EXEC_NONLINEAR))
     clearCacheData();
 }

◆ operator()() [1/6]

template<typename T >

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

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.

 {
   if (_always_evaluate)
     return evaluate(elem, state);
 
   mooseAssert(state.state == 0,
               "Cached evaluations are only currently supported for the current state.");
 
   return queryFVArgCache(_elem_arg_to_value, elem);
 }

◆ operator()() [2/6]

template<typename T >

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

Definition at line 610 of file MooseFunctor.h.

 {
   checkFace(face_in);
 
   if (_always_evaluate)
     return evaluate(face_in, state);
 
   mooseAssert(state.state == 0,
               "Cached evaluations are only currently supported for the current state.");
 
   return queryFVArgCache(_face_arg_to_value, face_in);
 }

◆ operator()() [3/6]

template<typename T >

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

Definition at line 656 of file MooseFunctor.h.

 {
   if (_always_evaluate)
     return evaluate(elem_qp, state);
 
   const auto elem_id = elem_qp.elem->id();
   if (elem_id != _current_qp_map_key)
   {
     _current_qp_map_key = elem_id;
     _current_qp_map_value = &_qp_to_value[elem_id];
   }
   auto & qp_data = *_current_qp_map_value;
   const auto qp = elem_qp.qp;
   const auto * const qrule = elem_qp.qrule;
   mooseAssert(qrule, "qrule must be non-null");
 
   return queryQpCache(qp, *qrule, qp_data, elem_qp, state);
 }

◆ operator()() [4/6]

template<typename T >

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

Definition at line 677 of file MooseFunctor.h.

 {
   if (_always_evaluate)
     return evaluate(elem_side_qp, state);
 
   const Elem * const elem = elem_side_qp.elem;
   mooseAssert(elem, "elem must be non-null");
   const auto elem_id = elem->id();
   if (elem_id != _current_side_qp_map_key)
   {
     _current_side_qp_map_key = elem_id;
     _current_side_qp_map_value = &_side_qp_to_value[elem_id];
   }
   auto & side_qp_data = *_current_side_qp_map_value;
   const auto side = elem_side_qp.side;
   const auto qp = elem_side_qp.qp;
   const auto * const qrule = elem_side_qp.qrule;
   mooseAssert(qrule, "qrule must be non-null");
 
   // Check and see whether we even have sized for this side
   if (side >= side_qp_data.size())
     side_qp_data.resize(elem->n_sides());
 
   // Ok we were sized enough for our side
   auto & qp_data = side_qp_data[side];
   return queryQpCache(qp, *qrule, qp_data, elem_side_qp, state);
 }

◆ operator()() [5/6]

template<typename T >

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

Definition at line 707 of file MooseFunctor.h.

 {
   return evaluate(elem_point, state);
 }

◆ operator()() [6/6]

template<typename T >

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

Definition at line 724 of file MooseFunctor.h.

 {
   mooseAssert(node.subdomain_ids, "Subdomain IDs must be supplied to the node argument");
   return evaluate(node, state);
 }

◆ queryFVArgCache()

template<typename T >

template<typename SpaceArg >

FunctorBase< T >::ValueType Moose::FunctorBase< T >::queryFVArgCache	(	std::map< SpaceArg, ValueType > &	cache_data,
		const SpaceArg &	space
	)		const

private

check a finite volume spatial argument cache and if invalid then evaluate

Definition at line 580 of file MooseFunctor.h.

 {
   // We don't want to evaluate if the key already exists, so instead we value initialize
   auto [it, inserted] = cache_data.try_emplace(space, ValueType());
   auto & value = it->second;
 
   if (inserted)
     // value not ready to go
     // this function is only called from functions that assert we are in the current time state
     value = evaluate(space, currentState());
 
   return value;
 }

◆ queryQpCache()

template<typename T>

template<typename SpaceArg , typename StateArg >

FunctorBase< T >::ValueType Moose::FunctorBase< T >::queryQpCache	(	unsigned int	qp,
		const libMesh::QBase &	qrule,
		std::vector< std::pair< bool, T >> &	qp_cache_data,
		const SpaceArg &	space,
		const StateArg &	state
	)		const

private

check a qp cache and if invalid then evaluate

Definition at line 626 of file MooseFunctor.h.

 {
   // Check and see whether we even have sized for this quadrature point. If we haven't then we
   // must evaluate
   if (qp >= qp_cache_data.size())
   {
     qp_cache_data.resize(qrule.n_points(), std::make_pair(false, ValueType()));
     auto & pr = qp_cache_data[qp];
     pr.second = evaluate(space, state);
     pr.first = true;
     return pr.second;
   }
 
   // We've already sized for this qp, so let's see whether we have a valid cache value
   auto & pr = qp_cache_data[qp];
   if (pr.first)
     return pr.second;
 
   // No valid cache value so evaluate
   pr.second = evaluate(space, state);
   pr.first = true;
   return pr.second;
 }

◆ residualSetup()

template<typename T >

void Moose::FunctorBase< T >::residualSetup ( )

overridevirtual

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< ComputeValueType >, MooseVariableField< RT >, 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.

 {
   if (_clearance_schedule.count(EXEC_LINEAR))
     clearCacheData();
 }

◆ setCacheClearanceSchedule()

template<typename T >

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

Set how often to clear the functor evaluation cache.

Definition at line 714 of file MooseFunctor.h.

 {
   if (clearance_schedule.count(EXEC_ALWAYS))
     _always_evaluate = true;
 
   _clearance_schedule = clearance_schedule;
 }

◆ supportsElemSideQpArg()

template<typename T>

virtual bool Moose::FunctorBase< T >::supportsElemSideQpArg ( ) const

pure virtual

Whether this functor supports evaluation with ElemSideQpArg.

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

◆ supportsFaceArg()

template<typename T>

virtual bool Moose::FunctorBase< T >::supportsFaceArg ( ) const

pure virtual

Whether this functor supports evaluation with FaceArg.

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

◆ timestepSetup()

template<typename T >

void Moose::FunctorBase< T >::timestepSetup ( )

overridevirtual

Implements Moose::FunctorAbstract.

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

Definition at line 815 of file MooseFunctor.h.

 {
   if (_clearance_schedule.count(EXEC_TIMESTEP_BEGIN))
     clearCacheData();
 }

Member Data Documentation

◆ _always_evaluate

template<typename T>

bool Moose::FunctorBase< T >::_always_evaluate

private

Boolean to check if we always need evaluation.

Definition at line 517 of file MooseFunctor.h.

◆ _clearance_schedule

template<typename T>

std::set<ExecFlagType> Moose::FunctorBase< T >::_clearance_schedule

private

How often to clear the material property cache.

Definition at line 514 of file MooseFunctor.h.

◆ _current_qp_map_key

template<typename T>

dof_id_type Moose::FunctorBase< T >::_current_qp_map_key = libMesh::DofObject::invalid_id

mutableprivate

Current key for qp map cache.

Definition at line 523 of file MooseFunctor.h.

◆ _current_qp_map_value

template<typename T>

std::vector<std::pair<bool, ValueType> >* Moose::FunctorBase< T >::_current_qp_map_value = nullptr

mutableprivate

Current value for qp map cache.

Definition at line 526 of file MooseFunctor.h.

◆ _current_side_qp_map_key

template<typename T>

dof_id_type Moose::FunctorBase< T >::_current_side_qp_map_key = libMesh::DofObject::invalid_id

mutableprivate

Current key for side-qp map cache.

Definition at line 539 of file MooseFunctor.h.

◆ _current_side_qp_map_value

template<typename T>

std::vector<std::vector<std::pair<bool, ValueType> > >* Moose::FunctorBase< T >::_current_side_qp_map_value

mutableprivate

Initial value:

=

nullptr

Current value for side-qp map cache.

Definition at line 542 of file MooseFunctor.h.

◆ _elem_arg_to_value

template<typename T>

std::map<ElemArg, ValueType> Moose::FunctorBase< T >::_elem_arg_to_value

mutableprivate

Map from element arguments to their cached evaluations.

Definition at line 555 of file MooseFunctor.h.

◆ _face_arg_to_value

template<typename T>

std::map<FaceArg, ValueType> Moose::FunctorBase< T >::_face_arg_to_value

mutableprivate

Map from face arguments to their cached evaluations.

Definition at line 558 of file MooseFunctor.h.

◆ _functor_name

template<typename T>

MooseFunctorName Moose::FunctorBase< T >::_functor_name

private

name of the functor

Definition at line 564 of file MooseFunctor.h.

Referenced by Moose::FunctorBase< libMesh::VectorValue >::functorName().

◆ _node_arg_to_value

template<typename T>

std::map<NodeArg, ValueType> Moose::FunctorBase< T >::_node_arg_to_value

mutableprivate

Map from nodal arguments to their cached evaluations.

Definition at line 561 of file MooseFunctor.h.

◆ _qp_to_value

template<typename T>

std::unordered_map<dof_id_type, std::vector<std::pair<bool, ValueType> > > Moose::FunctorBase< T >::_qp_to_value

mutableprivate

Cached element quadrature point functor property evaluations.

The map key is the element id. The map values should have size corresponding to the number of quadrature points on the element. The vector elements are pairs. The first member of the pair indicates whether a cached value has been computed. The second member of the pair is the (cached) value. If the boolean is false, then the value cannot be trusted

Definition at line 533 of file MooseFunctor.h.

◆ _side_qp_to_value

template<typename T>

std::unordered_map<dof_id_type, std::vector<std::vector<std::pair<bool, ValueType> > > > Moose::FunctorBase< T >::_side_qp_to_value

mutableprivate

Cached element quadrature point functor property evaluations.

The map key is the element id. The map values are a multi-dimensional vector (or vector of vectors) with the first index corresponding to the side and the second index corresponding to the quadrature point index. The elements returned after double indexing are pairs. The first member of the pair indicates whether a cached value has been computed. The second member of the pair is the (cached) value. If the boolean is false, then the value cannot be trusted

Definition at line 552 of file MooseFunctor.h.

The documentation for this class was generated from the following file:

include/base/MooseFunctor.h

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

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

Member Typedef Documentation

◆ DotType

◆ FunctorType

◆ GradientType

◆ ValueType

Constructor & Destructor Documentation

◆ ~FunctorBase()

◆ FunctorBase()

Member Function Documentation

◆ checkFace()

◆ clearCacheData()

◆ customSetup()

◆ dot() [1/6]

◆ dot() [2/6]

◆ dot() [3/6]

◆ dot() [4/6]

◆ dot() [5/6]

◆ dot() [6/6]

◆ evaluate() [1/6]

◆ evaluate() [2/6]

◆ evaluate() [3/6]

◆ evaluate() [4/6]

◆ evaluate() [5/6]

◆ evaluate() [6/6]

◆ evaluateDot() [1/6]

◆ evaluateDot() [2/6]

◆ evaluateDot() [3/6]

◆ evaluateDot() [4/6]

◆ evaluateDot() [5/6]

◆ evaluateDot() [6/6]

◆ evaluateGradDot() [1/6]

◆ evaluateGradDot() [2/6]

◆ evaluateGradDot() [3/6]

◆ evaluateGradDot() [4/6]

◆ evaluateGradDot() [5/6]

◆ evaluateGradDot() [6/6]

◆ evaluateGradient() [1/6]

◆ evaluateGradient() [2/6]

◆ evaluateGradient() [3/6]

◆ evaluateGradient() [4/6]

◆ evaluateGradient() [5/6]

◆ evaluateGradient() [6/6]

◆ functorName()

◆ genericEvaluate()

◆ gradDot() [1/6]

◆ gradDot() [2/6]

◆ gradDot() [3/6]

◆ gradDot() [4/6]

◆ gradDot() [5/6]

◆ gradDot() [6/6]

◆ gradient() [1/6]

◆ gradient() [2/6]

◆ gradient() [3/6]

◆ gradient() [4/6]

◆ gradient() [5/6]

◆ gradient() [6/6]

◆ hasBlocks()

◆ hasFaceSide()

◆ isConstant()

◆ isExtrapolatedBoundaryFace()

◆ isInternalFace()

◆ jacobianSetup()

◆ operator()() [1/6]

◆ operator()() [2/6]

◆ operator()() [3/6]

◆ operator()() [4/6]

◆ operator()() [5/6]

◆ operator()() [6/6]

◆ queryFVArgCache()

◆ queryQpCache()

◆ residualSetup()

◆ setCacheClearanceSchedule()

◆ supportsElemSideQpArg()

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