A material property that is evaluated on-the-fly via calls to various overloads of operator() More...

#include <PiecewiseByBlockLambdaFunctor.h>

Inheritance diagram for PiecewiseByBlockLambdaFunctor< 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
template<typename PolymorphicLambda >
	PiecewiseByBlockLambdaFunctor (const std::string &name, PolymorphicLambda my_lammy, const std::set< ExecFlagType > &clearance_schedule, const MooseMesh &mesh, const std::set< SubdomainID > &block_ids)

template<typename PolymorphicLambda >
void	setFunctor (const MooseMesh &mesh, const std::set< SubdomainID > &block_ids, PolymorphicLambda my_lammy)
	Set the functor that will be used in calls to `evaluate` overloads. More...

virtual	~PiecewiseByBlockLambdaFunctor ()=default

bool	isExtrapolatedBoundaryFace (const FaceInfo &fi, const Elem *elem, const Moose::StateArg &time) const override
	Returns whether this (sided) face is an extrapolated boundary face for this functor. More...

bool	hasBlocks (SubdomainID id) 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...

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


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 Types
using	ElemFn = std::function< T(const Moose::ElemArg &, const Moose::StateArg &)>

using	FaceFn = std::function< T(const Moose::FaceArg &, const Moose::StateArg &)>

using	ElemQpFn = std::function< T(const Moose::ElemQpArg &, const Moose::StateArg &)>

using	ElemSideQpFn = std::function< T(const Moose::ElemSideQpArg &, const Moose::StateArg &)>

using	ElemPointFn = std::function< T(const Moose::ElemPointArg &, const Moose::StateArg &)>

using	NodeFn = std::function< T(const Moose::NodeArg &, const Moose::StateArg &)>

Protected Member Functions
ValueType	evaluate (const Moose::ElemArg &elem_arg, const Moose::StateArg &time) const override
	Evaluate the functor with a given element. More...

ValueType	evaluate (const Moose::FaceArg &face, const Moose::StateArg &time) const override

ValueType	evaluate (const Moose::ElemQpArg &elem_qp, const Moose::StateArg &time) const override

ValueType	evaluate (const Moose::ElemSideQpArg &elem_side_qp, const Moose::StateArg &time) const override

ValueType	evaluate (const Moose::ElemPointArg &elem_point, const Moose::StateArg &time) const override
	Evaluate the functor with a given element and point. More...

ValueType	evaluate (const Moose::NodeArg &node_arg, const Moose::StateArg &time) const override

GradientType	evaluateGradient (const Moose::ElemArg &elem_arg, const Moose::StateArg &) const override
	Evaluate the functor gradient with a given element. More...

GradientType	evaluateGradient (const Moose::FaceArg &face_arg, const Moose::StateArg &) const override

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 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
template<typename C >
void	subdomainErrorMessage (SubdomainID sub_id, const std::unordered_map< SubdomainID, C > &functors) const
	Provide a useful error message about lack of functor material property on the provided subdomain `sub_id`. More...

Private Attributes
std::unordered_map< SubdomainID, ElemFn >	_elem_functor
	Functors that return element average values (or cell centroid values or whatever the implementer wants to return for a given element argument) More...

std::unordered_map< SubdomainID, FaceFn >	_face_functor
	Functors that return the property value on the requested side of the face (e.g. More...

std::unordered_map< SubdomainID, ElemQpFn >	_elem_qp_functor
	Functors that will evaluate elements at quadrature points. More...

std::unordered_map< SubdomainID, ElemSideQpFn >	_elem_side_qp_functor
	Functors that will evaluate elements at side quadrature points. More...

std::unordered_map< SubdomainID, ElemPointFn >	_elem_point_functor
	Functors that return evaluations at an arbitrary physical point in an element. More...

std::unordered_map< SubdomainID, NodeFn >	_node_functor
	Functors that return nodal values. More...

const MooseMesh &	_mesh
	The mesh that this functor operates on. More...

Detailed Description

template<typename T>
class PiecewiseByBlockLambdaFunctor< T >

A material property that is evaluated on-the-fly via calls to various overloads of operator()

Definition at line 32 of file PiecewiseByBlockLambdaFunctor.h.

Member Typedef Documentation

◆ DotType

template<typename T>

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

inherited

Definition at line 150 of file MooseFunctor.h.

◆ ElemFn

template<typename T >

using PiecewiseByBlockLambdaFunctor< T >::ElemFn = std::function<T(const Moose::ElemArg &, const Moose::StateArg &)>

protected

Definition at line 70 of file PiecewiseByBlockLambdaFunctor.h.

◆ ElemPointFn

template<typename T >

using PiecewiseByBlockLambdaFunctor< T >::ElemPointFn = std::function<T(const Moose::ElemPointArg &, const Moose::StateArg &)>

protected

Definition at line 74 of file PiecewiseByBlockLambdaFunctor.h.

◆ ElemQpFn

template<typename T >

using PiecewiseByBlockLambdaFunctor< T >::ElemQpFn = std::function<T(const Moose::ElemQpArg &, const Moose::StateArg &)>

protected

Definition at line 72 of file PiecewiseByBlockLambdaFunctor.h.

◆ ElemSideQpFn

template<typename T >

using PiecewiseByBlockLambdaFunctor< T >::ElemSideQpFn = std::function<T(const Moose::ElemSideQpArg &, const Moose::StateArg &)>

protected

Definition at line 73 of file PiecewiseByBlockLambdaFunctor.h.

◆ FaceFn

template<typename T >

using PiecewiseByBlockLambdaFunctor< T >::FaceFn = std::function<T(const Moose::FaceArg &, const Moose::StateArg &)>

protected

Definition at line 71 of file PiecewiseByBlockLambdaFunctor.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.

◆ NodeFn

template<typename T >

using PiecewiseByBlockLambdaFunctor< T >::NodeFn = std::function<T(const Moose::NodeArg &, const Moose::StateArg &)>

protected

Definition at line 75 of file PiecewiseByBlockLambdaFunctor.h.

◆ ValueType

template<typename T>

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

inherited

Definition at line 141 of file MooseFunctor.h.

Constructor & Destructor Documentation

◆ PiecewiseByBlockLambdaFunctor()

template<typename T >

template<typename PolymorphicLambda >

PiecewiseByBlockLambdaFunctor< T >::PiecewiseByBlockLambdaFunctor	(	const std::string &	name,
		PolymorphicLambda	my_lammy,
		const std::set< ExecFlagType > &	clearance_schedule,
		const MooseMesh &	mesh,
		const std::set< SubdomainID > &	block_ids
	)

Definition at line 129 of file PiecewiseByBlockLambdaFunctor.h.

   : Moose::FunctorBase<T>(name, clearance_schedule), _mesh(mesh)
 {
   setFunctor(mesh, block_ids, my_lammy);
 }

◆ ~PiecewiseByBlockLambdaFunctor()

template<typename T >

virtual PiecewiseByBlockLambdaFunctor< T >::~PiecewiseByBlockLambdaFunctor ( )

virtualdefault

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

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 738 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
 }

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

 {
   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

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

 {
   return evaluateDot(elem, state);
 }

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

 {
   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

inherited

Definition at line 911 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

inherited

Definition at line 918 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

inherited

Definition at line 925 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

inherited

Definition at line 932 of file MooseFunctor.h.

 {
   return evaluateDot(node, state);
 }

◆ evaluate() [1/6]

template<typename T >

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

overrideprotectedvirtual

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 234 of file PiecewiseByBlockLambdaFunctor.h.

 {
   const Elem * const elem = elem_arg.elem;
   mooseAssert(elem && elem != libMesh::remote_elem,
               "The element must be non-null and non-remote in functor material properties");
   auto it = _elem_functor.find(elem->subdomain_id());
   if (it == _elem_functor.end())
     subdomainErrorMessage(elem->subdomain_id(), _elem_functor);
 
   return it->second(elem_arg, time);
 }

◆ evaluate() [2/6]

template<typename T >

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

overrideprotectedvirtual

Parameters

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

Returns: The functor evaluated at the requested state and space

Implements Moose::FunctorBase< T >.

Definition at line 249 of file PiecewiseByBlockLambdaFunctor.h.

 {
   using namespace Moose::FV;
 
   if (face.face_side)
   {
     const auto sub_id = face.face_side->subdomain_id();
     auto it = _face_functor.find(sub_id);
     if (it == _face_functor.end())
       subdomainErrorMessage(sub_id, _face_functor);
 
     return it->second(face, time);
   }
 
   mooseAssert(this->isInternalFace(*face.fi),
               "If we did not have a face side, then we must be an internal face");
   return interpolate(*this, face, time);
 }

◆ evaluate() [3/6]

template<typename T >

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

overrideprotectedvirtual

Parameters

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

Returns: The functor evaluated at the requested state and space

Implements Moose::FunctorBase< T >.

Definition at line 271 of file PiecewiseByBlockLambdaFunctor.h.

 {
   const auto sub_id = elem_qp.elem->subdomain_id();
   auto it = _elem_qp_functor.find(sub_id);
   if (it == _elem_qp_functor.end())
     subdomainErrorMessage(sub_id, _elem_qp_functor);
 
   return it->second(elem_qp, time);
 }

◆ evaluate() [4/6]

template<typename T >

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

overrideprotectedvirtual

Parameters

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

Returns: The functor evaluated at the requested state and space

Implements Moose::FunctorBase< T >.

Definition at line 284 of file PiecewiseByBlockLambdaFunctor.h.

 {
   const auto sub_id = elem_side_qp.elem->subdomain_id();
   auto it = _elem_side_qp_functor.find(sub_id);
   if (it == _elem_side_qp_functor.end())
     subdomainErrorMessage(sub_id, _elem_side_qp_functor);
 
   return it->second(elem_side_qp, time);
 }

◆ evaluate() [5/6]

template<typename T >

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

overrideprotectedvirtual

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 297 of file PiecewiseByBlockLambdaFunctor.h.

 {
   const Elem * const elem = elem_point_arg.elem;
   mooseAssert(elem && elem != libMesh::remote_elem,
               "The element must be non-null and non-remote in functor material properties");
   auto it = _elem_point_functor.find(elem->subdomain_id());
   if (it == _elem_point_functor.end())
     subdomainErrorMessage(elem->subdomain_id(), _elem_point_functor);
 
   return it->second(elem_point_arg, time);
 }

◆ evaluate() [6/6]

template<typename T >

PiecewiseByBlockLambdaFunctor< T >::ValueType PiecewiseByBlockLambdaFunctor< T >::evaluate	(	const Moose::NodeArg &	node_arg,
		const Moose::StateArg &	time
	)		const

overrideprotectedvirtual

Implements Moose::FunctorBase< T >.

Definition at line 312 of file PiecewiseByBlockLambdaFunctor.h.

 {
   mooseAssert(node_arg.node, "The node must be non-null in functor material properties");
   if (node_arg.subdomain_ids->size() != 1)
     mooseError("We do not currently support multi-subdomain evaluation of nodal arguments");
   const auto sub_id = *(node_arg.subdomain_ids->begin());
   auto it = _node_functor.find(sub_id);
   if (it == _node_functor.end())
     subdomainErrorMessage(sub_id, _node_functor);
 
   return it->second(node_arg, time);
 }

◆ evaluateDot() [1/6]

template<typename T>

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

inlineprotectedvirtualinherited

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 391 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

inlineprotectedvirtualinherited

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 401 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

inlineprotectedvirtualinherited

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 411 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

inlineprotectedvirtualinherited

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 422 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

inlineprotectedvirtualinherited

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

Definition at line 431 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

inlineprotectedvirtualinherited

Definition at line 436 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

inlineprotectedvirtualinherited

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 445 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

inlineprotectedvirtualinherited

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 455 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

inlineprotectedvirtualinherited

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 465 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

inlineprotectedvirtualinherited

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 476 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

inlineprotectedvirtualinherited

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

Definition at line 485 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

inlineprotectedvirtualinherited

Definition at line 490 of file MooseFunctor.h.

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

◆ evaluateGradient() [1/6]

template<typename T >

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

overrideprotectedvirtual

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 328 of file PiecewiseByBlockLambdaFunctor.h.

 {
   return Moose::FV::greenGaussGradient(elem_arg, time, *this, true, _mesh);
 }

◆ evaluateGradient() [2/6]

template<typename T >

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

overrideprotectedvirtual

Parameters

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

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

Reimplemented from Moose::FunctorBase< T >.

Definition at line 336 of file PiecewiseByBlockLambdaFunctor.h.

 {
   return Moose::FV::greenGaussGradient(face_arg, time, *this, true, _mesh);
 }

◆ evaluateGradient() [3/6]

template<typename T>

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

inlineprotectedvirtualinherited

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, MooseVariableScalar, Postprocessor, Moose::ADWrapperFunctor< T >, and Moose::RawValueFunctor< T >.

Definition at line 358 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

inlineprotectedvirtualinherited

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 368 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

inlineprotectedvirtualinherited

Evaluate the functor gradient with a given element and point.

Definition at line 377 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

inlineprotectedvirtualinherited

Definition at line 382 of file MooseFunctor.h.

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

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

 {
   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

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

 {
   return evaluateGradDot(elem, state);
 }

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

 {
   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

inherited

Definition at line 954 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

inherited

Definition at line 961 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

inherited

Definition at line 968 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

inherited

Definition at line 975 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

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

 {
   return evaluateGradient(elem, state);
 }

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

 {
   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

inherited

Definition at line 868 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

inherited

Definition at line 875 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

inherited

Definition at line 882 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

inherited

Definition at line 889 of file MooseFunctor.h.

 {
   return evaluateGradient(node, state);
 }

◆ hasBlocks()

template<typename T >

bool PiecewiseByBlockLambdaFunctor< T >::hasBlocks ( SubdomainID ) const

overridevirtual

Returns whether the functor is defined on this block.

Reimplemented from Moose::FunctorBase< T >.

Definition at line 197 of file PiecewiseByBlockLambdaFunctor.h.

 {
   // If any of the maps has a functor for that block, it has the block
   const bool has_blocks = _elem_functor.count(id);
   mooseAssert(has_blocks == _face_functor.count(id),
               "All functor sets should agree on whether we have this sub id");
   mooseAssert(has_blocks == _elem_qp_functor.count(id),
               "All functor sets should agree on whether we have this sub id");
   mooseAssert(has_blocks == _elem_side_qp_functor.count(id),
               "All functor sets should agree on whether we have this sub id");
   return has_blocks;
 }

◆ hasFaceSide()

template<typename T >

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

overridevirtualinherited

Implements FaceArgInterface.

Definition at line 982 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

inlinevirtualinherited

Returns true if this functor is a constant.

Definition at line 266 of file MooseFunctor.h.

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

266 { return false; }

◆ isExtrapolatedBoundaryFace()

template<typename T >

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

overridevirtual

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

Reimplemented from Moose::FunctorBase< T >.

Definition at line 179 of file PiecewiseByBlockLambdaFunctor.h.

 {
   if (!fi.neighborPtr())
     return true;
 
   const bool defined_on_elem = _elem_functor.count(fi.elem().subdomain_id());
   const bool defined_on_neighbor = _elem_functor.count(fi.neighbor().subdomain_id());
   const bool extrapolated = (defined_on_elem + defined_on_neighbor) == 1;
 
   mooseAssert(defined_on_elem || defined_on_neighbor,
               "This shouldn't be called if we aren't defined on either side.");
   return extrapolated;
 }

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

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

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.

 {
   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

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.

 {
   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

inherited

Definition at line 616 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

inherited

Definition at line 662 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

inherited

Definition at line 683 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

inherited

Definition at line 713 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

inherited

Definition at line 730 of file MooseFunctor.h.

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

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

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

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

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

◆ setFunctor()

template<typename T >

template<typename PolymorphicLambda >

void PiecewiseByBlockLambdaFunctor< T >::setFunctor	(	const MooseMesh &	mesh,
		const std::set< SubdomainID > &	block_ids,
		PolymorphicLambda	my_lammy
	)

Set the functor that will be used in calls to evaluate overloads.

Parameters

mesh	The mesh that the functor is defined on
block_ids	The block/subdomain IDs that the user-provided functor is valid for
my_lammy	The functor that defines how this object is evaluated

Definition at line 143 of file PiecewiseByBlockLambdaFunctor.h.

Referenced by PiecewiseByBlockLambdaFunctor< T >::PiecewiseByBlockLambdaFunctor().

 {
   mooseAssert(&mesh == &_mesh,
               "We should always be setting this functor with the same mesh. We may relax this "
               "assertion later");
 
   auto add_lammy = [this, my_lammy](const SubdomainID block_id)
   {
     auto pr = _elem_functor.emplace(block_id, my_lammy);
     if (!pr.second)
       mooseError("No insertion for the functor material property '",
                  this->functorName(),
                  "' for block id ",
                  block_id,
                  ". Another material must already declare this property on that block.");
     _face_functor.emplace(block_id, my_lammy);
     _elem_qp_functor.emplace(block_id, my_lammy);
     _elem_side_qp_functor.emplace(block_id, my_lammy);
     _elem_point_functor.emplace(block_id, my_lammy);
     _node_functor.emplace(block_id, my_lammy);
   };
 
   for (const auto block_id : block_ids)
     add_lammy(block_id);
 
   // Handle special case of ANY_BLOCK_ID and empty block restriction that also cover
   // INVALID_BLOCK_ID
   if (block_ids.count(Moose::ANY_BLOCK_ID) || block_ids.empty() ||
       block_ids == mesh.meshSubdomains())
     add_lammy(Moose::INVALID_BLOCK_ID);
 }

◆ subdomainErrorMessage()

template<typename T >

template<typename C >

void PiecewiseByBlockLambdaFunctor< T >::subdomainErrorMessage	(	SubdomainID	sub_id,
		const std::unordered_map< SubdomainID, C > &	functors
	)		const

private

Provide a useful error message about lack of functor material property on the provided subdomain sub_id.

Parameters

sub_id	subdomain id on which the functor was missing
functors	map of functors, used to show list of blocks with a definition

Definition at line 213 of file PiecewiseByBlockLambdaFunctor.h.

 {
   std::vector<SubdomainID> block_ids;
   block_ids.reserve(functors.size());
   for (const auto & [available_sub_id, functor] : functors)
   {
     libmesh_ignore(functor);
     block_ids.push_back(available_sub_id);
   }
   mooseError("The provided subdomain ID ",
              std::to_string(sub_id),
              " doesn't exist in the map for lambda functor '",
              this->functorName(),
              "'! This is likely because you did not provide a functor material "
              "definition on that subdomain.\nSubdomain IDs in the map: ",
              Moose::stringify(block_ids));
 }

◆ supportsElemSideQpArg()

template<typename T >

bool PiecewiseByBlockLambdaFunctor< T >::supportsElemSideQpArg ( ) const

inlinefinaloverridevirtual

Whether this functor supports evaluation with ElemSideQpArg.

Implements Moose::FunctorBase< T >.

Definition at line 62 of file PiecewiseByBlockLambdaFunctor.h.

62 { return true; }

◆ supportsFaceArg()

template<typename T >

bool PiecewiseByBlockLambdaFunctor< T >::supportsFaceArg ( ) const

inlinefinaloverridevirtual

Whether this functor supports evaluation with FaceArg.

Implements Moose::FunctorBase< T >.

Definition at line 61 of file PiecewiseByBlockLambdaFunctor.h.

61 { 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.

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

Member Data Documentation

◆ _elem_functor

template<typename T >

std::unordered_map<SubdomainID, ElemFn> PiecewiseByBlockLambdaFunctor< T >::_elem_functor

private

Functors that return element average values (or cell centroid values or whatever the implementer wants to return for a given element argument)

Definition at line 105 of file PiecewiseByBlockLambdaFunctor.h.

◆ _elem_point_functor

template<typename T >

std::unordered_map<SubdomainID, ElemPointFn> PiecewiseByBlockLambdaFunctor< T >::_elem_point_functor

private

Functors that return evaluations at an arbitrary physical point in an element.

Definition at line 118 of file PiecewiseByBlockLambdaFunctor.h.

◆ _elem_qp_functor

template<typename T >

std::unordered_map<SubdomainID, ElemQpFn> PiecewiseByBlockLambdaFunctor< T >::_elem_qp_functor

private

Functors that will evaluate elements at quadrature points.

Definition at line 112 of file PiecewiseByBlockLambdaFunctor.h.

◆ _elem_side_qp_functor

template<typename T >

std::unordered_map<SubdomainID, ElemSideQpFn> PiecewiseByBlockLambdaFunctor< T >::_elem_side_qp_functor

private

Functors that will evaluate elements at side quadrature points.

Definition at line 115 of file PiecewiseByBlockLambdaFunctor.h.

◆ _face_functor

template<typename T >

std::unordered_map<SubdomainID, FaceFn> PiecewiseByBlockLambdaFunctor< T >::_face_functor

private

Functors that return the property value on the requested side of the face (e.g.

the infinitesimal + or - side of the face)

Definition at line 109 of file PiecewiseByBlockLambdaFunctor.h.

◆ _mesh

template<typename T >

const MooseMesh& PiecewiseByBlockLambdaFunctor< T >::_mesh

private

The mesh that this functor operates on.

Definition at line 124 of file PiecewiseByBlockLambdaFunctor.h.

◆ _node_functor

template<typename T >

std::unordered_map<SubdomainID, NodeFn> PiecewiseByBlockLambdaFunctor< T >::_node_functor

private

Functors that return nodal values.

Definition at line 121 of file PiecewiseByBlockLambdaFunctor.h.

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

include/utils/PiecewiseByBlockLambdaFunctor.h

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Private Member Functions

Private Attributes

Detailed Description

template<typename T> class PiecewiseByBlockLambdaFunctor< T >

Member Typedef Documentation

◆ DotType

◆ ElemFn

◆ ElemPointFn

◆ ElemQpFn

◆ ElemSideQpFn

◆ FaceFn

◆ FunctorType

◆ GradientType

◆ NodeFn

◆ ValueType

Constructor & Destructor Documentation

◆ PiecewiseByBlockLambdaFunctor()

◆ ~PiecewiseByBlockLambdaFunctor()

Member Function Documentation

◆ checkFace()

◆ 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]

template<typename T>
class PiecewiseByBlockLambdaFunctor< T >