Base class for computing layered side integrals. More...

#include <LayeredIntegralBase.h>

Inheritance diagram for LayeredIntegralBase< UserObjectType >:

Public Types
using	FunctorType = FunctorBase< Real >

using	ValueType = Real

using	GradientType = typename FunctorReturnType< Real, 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
	LayeredIntegralBase (const InputParameters &parameters)

virtual Real	spatialValue (const Point &p) const override
	Given a Point return the integral value associated with the layer that point falls in. More...

virtual const std::vector< Point >	spatialPoints () const override

virtual void	initialize () override

virtual void	execute () override

virtual void	finalize () override

virtual void	threadJoin (const UserObject &y) override

virtual bool	hasBlocks (SubdomainID sub) const override
	Returns whether the functor is defined on this block. More...

template<typename SpatialArg >
Real	evaluateTemplate (const SpatialArg &position, const Moose::StateArg &libmesh_dbg_var(state)) const

FunctorReturnType< Real, FET >::type	genericEvaluate (const Space &r, const State &state) const
	Perform a generic evaluation based on the supplied template argument `FET` and supplied spatial and temporal arguments. More...

const MooseFunctorName &	functorName () const
	Return the functor name. More...

virtual void	residualSetup () override

virtual void	jacobianSetup () override

virtual void	timestepSetup () override

virtual void	customSetup (const ExecFlagType &exec_type) override

void	setCacheClearanceSchedule (const std::set< ExecFlagType > &clearance_schedule)
	Set how often to clear the functor evaluation cache. More...

virtual bool	isExtrapolatedBoundaryFace (const FaceInfo &, const Elem *, const StateArg &) const
	Returns whether this (sided) face is an extrapolated boundary face for this functor. More...

bool	isInternalFace (const FaceInfo &) const
	Returns true if the face is an internal face. More...

virtual bool	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 Real	integralValue (const Point &p) const
	Given a Point return the integral value associated with the layer that point falls in. More...

virtual Real	getLayerValue (unsigned int layer) const
	Get the value for a given layer. More...

virtual unsigned int	getLayer (const Point &p) const
	Helper function to return the layer the point lies in. More...

const std::vector< Real > &	getLayerCenters () const
	Get the center coordinates for the layers (along given direction) More...

unsigned int	direction () const
	Get direction of the layers. 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

Static Public Member Functions
static InputParameters	validParams ()

Protected Types
using	ElemArg = Moose::ElemArg

using	ElemQpArg = Moose::ElemQpArg

using	ElemSideQpArg = Moose::ElemSideQpArg

using	FaceArg = Moose::FaceArg

using	ElemPointArg = Moose::ElemPointArg

using	NodeArg = Moose::NodeArg

Protected Member Functions
virtual Real	evaluate (const ElemArg &elem, const Moose::StateArg &state) const override
	Evaluate the functor with a given element. More...

virtual Real	evaluate (const FaceArg &face, const Moose::StateArg &state) const override final

virtual Real	evaluate (const ElemQpArg &qp, const Moose::StateArg &state) const override

virtual Real	evaluate (const ElemSideQpArg &elem_side_qp, const Moose::StateArg &state) const override final

virtual Real	evaluate (const ElemPointArg &elem_point, const Moose::StateArg &state) const override final
	Evaluate the functor with a given element and point. More...

virtual Real	evaluate (const NodeArg &node, const Moose::StateArg &state) const override final

virtual bool	supportsFaceArg () const override final
	Whether this functor supports evaluation with FaceArg. More...

virtual bool	supportsElemSideQpArg () const override final
	Whether this functor supports evaluation with ElemSideQpArg. More...

void	setLayerValue (unsigned int layer, Real value)
	Set the value for a particular layer. More...

bool	layerHasValue (unsigned int layer) const
	Whether or not a layer has a value. More...

void	getBounds ()
	Compute bounds, restricted to blocks if given. More...

void	computeLayerCenters ()
	Compute the center points for each layer. More...

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

Protected Attributes
std::string	_layered_base_name
	Name of this object. More...

const InputParameters &	_layered_base_params
	Params for this object. More...

MooseEnum	_direction_enum
	The MooseEnum direction the layers are going in. More...

unsigned int	_direction
	The component direction the layers are going in. We cache this for speed (so we're not always going through the MooseEnum) More...

bool	_interval_based
	Whether or not this object is based on equally spaced intervals or "bounds". More...

unsigned int	_num_layers
	Number of layers to split the mesh into. More...

std::vector< Real >	_layer_bounds
	The boundaries of the layers. More...

unsigned int	_sample_type
	How to sample the values. More...

unsigned int	_average_radius
	How many layers both above and below the found layer will be used in the average. More...

bool	_using_displaced_mesh
	true if this object operates on the displaced mesh, otherwise false More...

std::vector< Real >	_layer_centers
	center coordinates of each layer More...

Real	_direction_min

Real	_direction_max

std::vector< Real > &	_layer_values
	Value of the integral for each layer. More...

std::vector< int > &	_layer_has_value
	Whether or not each layer has had any value summed into it. More...

bool	_cumulative
	Whether the values are cumulative over the layers. More...

const bool	_positive_cumulative_direction
	Whether the cumulative values should be summed in the positive or negative direction. More...

Detailed Description

template<typename UserObjectType>
class LayeredIntegralBase< UserObjectType >

Base class for computing layered side integrals.

Definition at line 20 of file LayeredIntegralBase.h.

Member Typedef Documentation

◆ DotType

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

inherited

Definition at line 150 of file MooseFunctor.h.

◆ ElemArg

template<typename UserObjectType>

using SpatialUserObjectFunctor< UserObjectType >::ElemArg = Moose::ElemArg

protectedinherited

Definition at line 29 of file SpatialUserObjectFunctor.h.

◆ ElemPointArg

template<typename UserObjectType>

using SpatialUserObjectFunctor< UserObjectType >::ElemPointArg = Moose::ElemPointArg

protectedinherited

Definition at line 33 of file SpatialUserObjectFunctor.h.

◆ ElemQpArg

template<typename UserObjectType>

using SpatialUserObjectFunctor< UserObjectType >::ElemQpArg = Moose::ElemQpArg

protectedinherited

Definition at line 30 of file SpatialUserObjectFunctor.h.

◆ ElemSideQpArg

template<typename UserObjectType>

using SpatialUserObjectFunctor< UserObjectType >::ElemSideQpArg = Moose::ElemSideQpArg

protectedinherited

Definition at line 31 of file SpatialUserObjectFunctor.h.

◆ FaceArg

template<typename UserObjectType>

using SpatialUserObjectFunctor< UserObjectType >::FaceArg = Moose::FaceArg

protectedinherited

Definition at line 32 of file SpatialUserObjectFunctor.h.

◆ FunctorType

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

inherited

Definition at line 140 of file MooseFunctor.h.

◆ GradientType

using Moose::FunctorBase< Real >::GradientType = typename FunctorReturnType<Real , 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.

◆ NodeArg

template<typename UserObjectType>

using SpatialUserObjectFunctor< UserObjectType >::NodeArg = Moose::NodeArg

protectedinherited

Definition at line 34 of file SpatialUserObjectFunctor.h.

◆ ValueType

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

inherited

Definition at line 141 of file MooseFunctor.h.

Constructor & Destructor Documentation

◆ LayeredIntegralBase()

template<typename UserObjectType >

LayeredIntegralBase< UserObjectType >::LayeredIntegralBase ( const InputParameters & parameters )

Definition at line 56 of file LayeredIntegralBase.h.

   : SpatialUserObjectFunctor<UserObjectType>(parameters), LayeredBase(parameters)
 {
   if (parameters.isParamValid("block") && parameters.isParamValid("boundary"))
     mooseError("Both block and boundary cannot be specified for a layered integral user object. If "
                "you want to define the geometric bounds of the layers from a specified block set "
                "layer_bounding_block instead.");
 }

Member Function Documentation

◆ checkFace()

void Moose::FunctorBase< Real >::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
 }

◆ computeLayerCenters()

void LayeredBase::computeLayerCenters ( )

protectedinherited

Compute the center points for each layer.

Definition at line 442 of file LayeredBase.C.

Referenced by LayeredBase::LayeredBase().

 {
   _layer_centers.resize(_num_layers);
 
   if (_interval_based)
   {
     Real dx = (_direction_max - _direction_min) / _num_layers;
 
     for (const auto i : make_range(_num_layers))
       _layer_centers[i] = (i + 0.5) * dx;
   }
   else
   {
     for (const auto i : make_range(_num_layers))
       _layer_centers[i] = 0.5 * (_layer_bounds[i + 1] + _layer_bounds[i]);
   }
 }

◆ customSetup()

void Moose::FunctorBase< Real >::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();
 }

◆ direction()

unsigned int LayeredBase::direction ( ) const

inlineinherited

Get direction of the layers.

Returns: layer direction

Definition at line 73 of file LayeredBase.h.

73 { return _direction; }

LayeredBase::_direction

unsigned int _direction

The component direction the layers are going in. We cache this for speed (so we're not always going t...

Definition: LayeredBase.h:112

◆ dot() [1/6]

FunctorBase< Real >::DotType Moose::FunctorBase< Real >::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.

 {
   return evaluateDot(elem, state);
 }

◆ dot() [2/6]

FunctorBase< Real >::DotType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::DotType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::DotType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::DotType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::DotType Moose::FunctorBase< Real >::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 UserObjectType >

Real SpatialUserObjectFunctor< UserObjectType >::evaluate	(	const ElemArg &	elem,
		const Moose::StateArg &	state
	)		const

overrideprotectedvirtualinherited

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

Definition at line 85 of file SpatialUserObjectFunctor.h.

 {
   return evaluateTemplate(elem, state);
 }

◆ evaluate() [2/6]

template<typename UserObjectType >

Real SpatialUserObjectFunctor< UserObjectType >::evaluate	(	const FaceArg &	face,
		const Moose::StateArg &	state
	)		const

finaloverrideprotectedvirtualinherited

Parameters

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

Returns: The functor evaluated at the requested state and space

Implements Moose::FunctorBase< Real >.

Definition at line 93 of file SpatialUserObjectFunctor.h.

 {
   return evaluateTemplate(face, state);
 }

◆ evaluate() [3/6]

template<typename UserObjectType >

Real SpatialUserObjectFunctor< UserObjectType >::evaluate	(	const ElemQpArg &	qp,
		const Moose::StateArg &	state
	)		const

overrideprotectedvirtualinherited

Parameters

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

Returns: The functor evaluated at the requested state and space

Implements Moose::FunctorBase< Real >.

Definition at line 101 of file SpatialUserObjectFunctor.h.

 {
   return evaluateTemplate(qp, state);
 }

◆ evaluate() [4/6]

template<typename UserObjectType >

Real SpatialUserObjectFunctor< UserObjectType >::evaluate	(	const ElemSideQpArg &	side_qp,
		const Moose::StateArg &	state
	)		const

finaloverrideprotectedvirtualinherited

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

Definition at line 109 of file SpatialUserObjectFunctor.h.

 {
   return evaluateTemplate(elem_side_qp, state);
 }

◆ evaluate() [5/6]

template<typename UserObjectType >

Real SpatialUserObjectFunctor< UserObjectType >::evaluate	(	const ElemPointArg &	elem_point,
		const Moose::StateArg &	state
	)		const

finaloverrideprotectedvirtualinherited

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

Definition at line 117 of file SpatialUserObjectFunctor.h.

 {
   return evaluateTemplate(elem_point, state);
 }

◆ evaluate() [6/6]

template<typename UserObjectType >

Real SpatialUserObjectFunctor< UserObjectType >::evaluate	(	const NodeArg &	node,
		const Moose::StateArg &	state
	)		const

finaloverrideprotectedvirtualinherited

Implements Moose::FunctorBase< Real >.

Definition at line 125 of file SpatialUserObjectFunctor.h.

 {
   return evaluateTemplate(node, state);
 }

◆ evaluateDot() [1/6]

virtual DotType Moose::FunctorBase< Real >::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::FunctorEnvelope< Real >, Function, and Postprocessor.

Definition at line 391 of file MooseFunctor.h.

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

◆ evaluateDot() [2/6]

virtual DotType Moose::FunctorBase< Real >::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

Reimplemented in Moose::FunctorEnvelope< Real >, Function, and Postprocessor.

Definition at line 401 of file MooseFunctor.h.

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

◆ evaluateDot() [3/6]

virtual DotType Moose::FunctorBase< Real >::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

Reimplemented in Moose::FunctorEnvelope< Real >, Function, and Postprocessor.

Definition at line 411 of file MooseFunctor.h.

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

◆ evaluateDot() [4/6]

virtual DotType Moose::FunctorBase< Real >::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

Reimplemented in Moose::FunctorEnvelope< Real >, Function, and Postprocessor.

Definition at line 422 of file MooseFunctor.h.

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

◆ evaluateDot() [5/6]

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

inlineprotectedvirtualinherited

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

Reimplemented in Moose::FunctorEnvelope< Real >, Function, and Postprocessor.

Definition at line 431 of file MooseFunctor.h.

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

◆ evaluateDot() [6/6]

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

inlineprotectedvirtualinherited

Reimplemented in Moose::FunctorEnvelope< Real >, Function, and Postprocessor.

Definition at line 436 of file MooseFunctor.h.

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

◆ evaluateGradDot() [1/6]

virtual GradientType Moose::FunctorBase< Real >::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

Reimplemented in Moose::FunctorEnvelope< Real >.

Definition at line 445 of file MooseFunctor.h.

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

◆ evaluateGradDot() [2/6]

virtual GradientType Moose::FunctorBase< Real >::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

Reimplemented in Moose::FunctorEnvelope< Real >.

Definition at line 455 of file MooseFunctor.h.

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

◆ evaluateGradDot() [3/6]

virtual GradientType Moose::FunctorBase< Real >::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

Reimplemented in Moose::FunctorEnvelope< Real >.

Definition at line 465 of file MooseFunctor.h.

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

◆ evaluateGradDot() [4/6]

virtual GradientType Moose::FunctorBase< Real >::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

Reimplemented in Moose::FunctorEnvelope< Real >.

Definition at line 476 of file MooseFunctor.h.

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

◆ evaluateGradDot() [5/6]

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

inlineprotectedvirtualinherited

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

Reimplemented in Moose::FunctorEnvelope< Real >.

Definition at line 485 of file MooseFunctor.h.

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

◆ evaluateGradDot() [6/6]

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

inlineprotectedvirtualinherited

Reimplemented in Moose::FunctorEnvelope< Real >.

Definition at line 490 of file MooseFunctor.h.

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

◆ evaluateGradient() [1/6]

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

inlineprotectedvirtualinherited

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::FunctorEnvelope< Real >, Function, and Postprocessor.

Definition at line 338 of file MooseFunctor.h.

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

◆ evaluateGradient() [2/6]

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

inlineprotectedvirtualinherited

Parameters

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

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

Reimplemented in Moose::FunctorEnvelope< Real >, Function, and Postprocessor.

Definition at line 348 of file MooseFunctor.h.

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

◆ evaluateGradient() [3/6]

virtual GradientType Moose::FunctorBase< Real >::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::FunctorEnvelope< Real >, Function, and Postprocessor.

Definition at line 358 of file MooseFunctor.h.

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

◆ evaluateGradient() [4/6]

virtual GradientType Moose::FunctorBase< Real >::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

Reimplemented in Moose::FunctorEnvelope< Real >, Function, and Postprocessor.

Definition at line 368 of file MooseFunctor.h.

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

◆ evaluateGradient() [5/6]

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

inlineprotectedvirtualinherited

Evaluate the functor gradient with a given element and point.

Reimplemented in Moose::FunctorEnvelope< Real >, Function, and Postprocessor.

Definition at line 377 of file MooseFunctor.h.

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

◆ evaluateGradient() [6/6]

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

inlineprotectedvirtualinherited

Reimplemented in Moose::FunctorEnvelope< Real >, Function, and Postprocessor.

Definition at line 382 of file MooseFunctor.h.

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

◆ evaluateTemplate()

template<typename UserObjectType>

template<typename SpatialArg >

Real SpatialUserObjectFunctor< UserObjectType >::evaluateTemplate	(	const SpatialArg &	position,
		const Moose::StateArg &	libmesh_dbg_varstate
	)		const

inherited

Definition at line 76 of file SpatialUserObjectFunctor.h.

 {
   mooseAssert(state.state == 0, "We do not currently support evaluating at old states");
   return this->spatialValue(position.getPoint());
 }

◆ execute()

template<typename UserObjectType >

void LayeredIntegralBase< UserObjectType >::execute ( )

overridevirtual

Reimplemented in LayeredAverageBase< BaseType >, LayeredAverageBase< SideIntegralFunctorUserObject >, LayeredAverageBase< SideIntegralVariableUserObject >, LayeredAverageBase< ElementIntegralFunctorUserObject >, and LayeredAverageBase< ElementIntegralVariableUserObject >.

Definition at line 75 of file LayeredIntegralBase.h.

Referenced by LayeredAverageBase< ElementIntegralVariableUserObject >::execute().

 {
   const auto integral_value = computeIntegral();
 
   const auto layer = getLayer(_current_elem->vertex_average());
 
   setLayerValue(layer, getLayerValue(layer) + integral_value);
 }

◆ finalize()

template<typename UserObjectType >

void LayeredIntegralBase< UserObjectType >::finalize ( )

overridevirtual

Reimplemented from LayeredBase.

Reimplemented in LayeredAverageBase< BaseType >, LayeredAverageBase< SideIntegralFunctorUserObject >, LayeredAverageBase< SideIntegralVariableUserObject >, LayeredAverageBase< ElementIntegralFunctorUserObject >, and LayeredAverageBase< ElementIntegralVariableUserObject >.

Definition at line 86 of file LayeredIntegralBase.h.

Referenced by LayeredAverageBase< ElementIntegralVariableUserObject >::finalize().

 {
   LayeredBase::finalize();
 }

◆ functorName()

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

inlineinherited

Return the functor name.

Definition at line 176 of file MooseFunctor.h.

176 { return _functor_name; }

Moose::FunctorBase< Real >::_functor_name

MooseFunctorName _functor_name

name of the functor

Definition: MooseFunctor.h:570

◆ genericEvaluate()

FunctorReturnType< Real , FET >::type Moose::FunctorBase< Real >::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);
 }

◆ getBounds()

void LayeredBase::getBounds ( )

protectedinherited

Compute bounds, restricted to blocks if given.

Definition at line 468 of file LayeredBase.C.

Referenced by LayeredBase::initialize(), and LayeredBase::LayeredBase().

 {
   if (_layer_bounding_blocks.size() == 0)
   {
     BoundingBox bounding_box = MeshTools::create_bounding_box(_layered_base_subproblem.mesh());
     _direction_min = bounding_box.min()(_direction);
     _direction_max = bounding_box.max()(_direction);
   }
   else
   {
     _direction_min = std::numeric_limits<Real>::infinity();
     _direction_max = -std::numeric_limits<Real>::infinity();
 
     MooseMesh & mesh = _layered_base_subproblem.mesh();
 
     for (auto & elem_ptr : *mesh.getActiveLocalElementRange())
     {
       auto subdomain_id = elem_ptr->subdomain_id();
 
       if (std::find(_layer_bounding_blocks.begin(), _layer_bounding_blocks.end(), subdomain_id) ==
           _layer_bounding_blocks.end())
         continue;
 
       for (auto & node : elem_ptr->node_ref_range())
       {
         _direction_min = std::min(_direction_min, node(_direction));
         _direction_max = std::max(_direction_max, node(_direction));
       }
     }
 
     mesh.comm().min(_direction_min);
     mesh.comm().max(_direction_max);
   }
 }

◆ getLayer()

unsigned int LayeredBase::getLayer ( const Point & p ) const

virtualinherited

Helper function to return the layer the point lies in.

Parameters

p	The point.

Returns: The layer the Point is found in.

Definition at line 402 of file LayeredBase.C.

Referenced by LayeredExtremumMaterialProperty::execute(), FunctionLayeredIntegral::execute(), and LayeredBase::integralValue().

 {
   Real direction_x = p(_direction);
 
   if (direction_x < _direction_min)
     return 0;
 
   if (_interval_based)
   {
     unsigned int layer =
         std::floor(((direction_x - _direction_min) / (_direction_max - _direction_min)) *
                    static_cast<Real>(_num_layers));
 
     if (layer >= _num_layers)
       layer = _num_layers - 1;
 
     return layer;
   }
   else // Figure out what layer we are in from the bounds
   {
     // This finds the first entry in the vector that is larger than what we're looking for
     std::vector<Real>::const_iterator one_higher =
         std::upper_bound(_layer_bounds.begin(), _layer_bounds.end(), direction_x);
 
     if (one_higher == _layer_bounds.end())
     {
       return static_cast<unsigned int>(
           _layer_bounds.size() -
           2); // Just return the last layer.  -2 because layers are "in-between" bounds
     }
     else if (one_higher == _layer_bounds.begin())
       return 0; // Return the first layer
     else
       // The -1 is because the interval that we fall in is just _before_ the number that is bigger
       // (which is what we found
       return static_cast<unsigned int>(std::distance(_layer_bounds.begin(), one_higher - 1));
   }
 }

◆ getLayerCenters()

const std::vector<Real>& LayeredBase::getLayerCenters ( ) const

inlineinherited

Get the center coordinates for the layers (along given direction)

Definition at line 67 of file LayeredBase.h.

Referenced by NearestPointBase< LayeredSideDiffusiveFluxAverage, SideIntegralVariableUserObject >::spatialPoints().

67 { return _layer_centers; }

LayeredBase::_layer_centers

std::vector< Real > _layer_centers

center coordinates of each layer

Definition: LayeredBase.h:133

◆ getLayerValue()

Real LayeredBase::getLayerValue ( unsigned int layer ) const

virtualinherited

Get the value for a given layer.

Parameters

layer The layer index

Returns: The value for the given layer

Definition at line 347 of file LayeredBase.C.

Referenced by LayeredExtremumMaterialProperty::execute(), FunctionLayeredIntegral::execute(), LayeredExtremumMaterialProperty::finalize(), LayeredBase::finalize(), LayeredExtremumMaterialProperty::threadJoin(), and LayeredBase::threadJoin().

 {
   if (layer >= _layer_values.size())
     mooseError("Layer '", layer, "' not found in '", _layered_base_name, "'.");
   return _layer_values[layer];
 }

◆ gradDot() [1/6]

FunctorBase< Real >::GradientType Moose::FunctorBase< Real >::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.

 {
   return evaluateGradDot(elem, state);
 }

◆ gradDot() [2/6]

FunctorBase< Real >::GradientType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::GradientType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::GradientType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::GradientType Moose::FunctorBase< Real >::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]

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

inherited

Definition at line 975 of file MooseFunctor.h.

 {
   return evaluateGradDot(node, state);
 }

◆ gradient() [1/6]

FunctorBase< Real >::GradientType Moose::FunctorBase< Real >::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.

 {
   return evaluateGradient(elem, state);
 }

◆ gradient() [2/6]

FunctorBase< Real >::GradientType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::GradientType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::GradientType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::GradientType Moose::FunctorBase< Real >::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]

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

inherited

Definition at line 889 of file MooseFunctor.h.

 {
   return evaluateGradient(node, state);
 }

◆ hasBlocks()

template<typename UserObjectType >

bool SpatialUserObjectFunctor< UserObjectType >::hasBlocks ( SubdomainID ) const

overridevirtualinherited

Returns whether the functor is defined on this block.

Reimplemented from Moose::FunctorBase< Real >.

Reimplemented in MeshDivisionFunctorReductionVectorPostprocessor.

Definition at line 133 of file SpatialUserObjectFunctor.h.

 {
   if constexpr (std::is_base_of<BlockRestrictable, UserObjectType>::value)
     return UserObjectType::hasBlocks(sub_id);
   else
     return Moose::FunctorBase<Real>::hasBlocks(sub_id);
 }

◆ hasFaceSide()

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

overridevirtualinherited

Implements FaceArgInterface.

Reimplemented in Moose::FunctorEnvelope< Real >, InternalSideIntegralVariablePostprocessor, InterfaceIntegralVariableValuePostprocessor, SideIntegralVariablePostprocessor, SideIntegralFunctorPostprocessorTempl< is_ad >, and SideIntegralFunctorPostprocessorTempl< false >.

Definition at line 982 of file MooseFunctor.h.

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

◆ initialize()

template<typename UserObjectType >

void LayeredIntegralBase< UserObjectType >::initialize ( )

overridevirtual

Reimplemented from LayeredBase.

Reimplemented in LayeredAverageBase< BaseType >, LayeredAverageBase< SideIntegralFunctorUserObject >, LayeredAverageBase< SideIntegralVariableUserObject >, LayeredAverageBase< ElementIntegralFunctorUserObject >, and LayeredAverageBase< ElementIntegralVariableUserObject >.

Definition at line 67 of file LayeredIntegralBase.h.

Referenced by LayeredAverageBase< ElementIntegralVariableUserObject >::initialize().

 {
   UserObjectType::initialize();
   LayeredBase::initialize();
 }

◆ integralValue()

Real LayeredBase::integralValue ( const Point & p ) const

virtualinherited

Given a Point return the integral value associated with the layer that point falls in.

Parameters

p	The point to look for in the layers.

Definition at line 236 of file LayeredBase.C.

Referenced by LayeredExtremumMaterialProperty::spatialValue(), LayeredIntegralBase< ElementIntegralVariableUserObject >::spatialValue(), and FunctionLayeredIntegral::spatialValue().

 {
   unsigned int layer = getLayer(p);
 
   int higher_layer = -1;
   int lower_layer = -1;
 
   for (unsigned int i = layer; i < _layer_values.size(); i++)
   {
     if (_layer_has_value[i])
     {
       higher_layer = i;
       break;
     }
   }
 
   for (int i = layer - 1; i >= 0; i--)
   {
     if (_layer_has_value[i])
     {
       lower_layer = i;
       break;
     }
   }
 
   if (higher_layer == -1 && lower_layer == -1)
     return 0; // TODO: We could error here but there are startup dependency problems
 
   switch (_sample_type)
   {
     case 0: // direct
     {
       if (higher_layer == -1) // Didn't find a higher layer
         return _layer_values[lower_layer];
 
       if (unsigned(higher_layer) == layer) // constant in a layer
         return _layer_values[higher_layer];
 
       if (lower_layer == -1) // Didn't find a lower layer
         return _layer_values[higher_layer];
 
       return (_layer_values[higher_layer] + _layer_values[lower_layer]) / 2;
     }
     case 1: // interpolate
     {
       if (higher_layer == -1) // Didn't find a higher layer
         return _layer_values[lower_layer];
 
       Real layer_length = (_direction_max - _direction_min) / _num_layers;
       Real lower_coor = _direction_min;
       Real lower_value = 0;
       if (lower_layer != -1)
       {
         lower_coor += (lower_layer + 1) * layer_length;
         lower_value = _layer_values[lower_layer];
       }
 
       // Interpolate between the two points
       Real higher_value = _layer_values[higher_layer];
 
       // Linear interpolation
       return lower_value +
              (higher_value - lower_value) * (p(_direction) - lower_coor) / layer_length;
     }
     case 2: // average
     {
       Real total = 0;
       unsigned int num_values = 0;
 
       if (higher_layer != -1)
       {
         for (const auto i : make_range(_average_radius))
         {
           int current_layer = higher_layer + i;
 
           if ((size_t)current_layer >= _layer_values.size())
             break;
 
           if (_layer_has_value[current_layer])
           {
             total += _layer_values[current_layer];
             num_values += 1;
           }
         }
       }
 
       if (lower_layer != -1)
       {
         for (const auto i : make_range(_average_radius))
         {
           int current_layer = lower_layer - i;
 
           if (current_layer < 0)
             break;
 
           if (_layer_has_value[current_layer])
           {
             total += _layer_values[current_layer];
             num_values += 1;
           }
         }
       }
 
       return total / num_values;
     }
     default:
       mooseError("Unknown sample type!");
   }
 }

◆ isConstant()

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

inlinevirtualinherited

Returns true if this functor is a constant.

Reimplemented in Moose::FunctorEnvelope< Real >.

Definition at line 266 of file MooseFunctor.h.

266 { return false; }

◆ isExtrapolatedBoundaryFace()

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

inlinevirtualinherited

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

Reimplemented in Moose::FunctorEnvelope< Real >.

Definition at line 253 of file MooseFunctor.h.

   {
     mooseError("not implemented");
   }

◆ isInternalFace()

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

inherited

Returns true if the face is an internal face.

Definition at line 575 of file MooseFunctor.h.

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

◆ jacobianSetup()

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

overridevirtualinherited

Implements Moose::FunctorAbstract.

Reimplemented in Function.

Definition at line 837 of file MooseFunctor.h.

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

◆ layerHasValue()

bool LayeredBase::layerHasValue ( unsigned int layer ) const

inlineprotectedinherited

Whether or not a layer has a value.

Definition at line 90 of file LayeredBase.h.

90 { return _layer_has_value[layer]; }

LayeredBase::_layer_has_value

std::vector< int > & _layer_has_value

Whether or not each layer has had any value summed into it.

Definition: LayeredBase.h:142

◆ operator()() [1/6]

FunctorBase< Real >::ValueType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::ValueType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::ValueType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::ValueType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::ValueType Moose::FunctorBase< Real >::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]

FunctorBase< Real >::ValueType Moose::FunctorBase< Real >::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()

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

overridevirtualinherited

Implements Moose::FunctorAbstract.

Reimplemented in Function.

Definition at line 829 of file MooseFunctor.h.

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

◆ setCacheClearanceSchedule()

void Moose::FunctorBase< Real >::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;
 }

◆ setLayerValue()

void LayeredBase::setLayerValue	(	unsigned int	layer,
		Real	value
	)

protectedinherited

Set the value for a particular layer.

Parameters

layer	The layer you are setting the value for
value	The value to set

Definition at line 461 of file LayeredBase.C.

Referenced by LayeredExtremumMaterialProperty::execute(), FunctionLayeredIntegral::execute(), LayeredExtremumMaterialProperty::finalize(), LayeredBase::finalize(), LayeredExtremumMaterialProperty::initialize(), LayeredExtremumMaterialProperty::threadJoin(), and LayeredBase::threadJoin().

 {
   _layer_values[layer] = value;
   _layer_has_value[layer] = true;
 }

◆ spatialPoints()

template<typename UserObjectType >

const std::vector< Point > LayeredIntegralBase< UserObjectType >::spatialPoints ( ) const

overridevirtual

Definition at line 101 of file LayeredIntegralBase.h.

 {
   std::vector<Point> points;
 
   for (const auto & l : _layer_centers)
   {
     Point pt(0.0, 0.0, 0.0);
     pt(_direction) = l;
     points.push_back(pt);
   }
 
   return points;
 }

◆ spatialValue()

template<typename UserObjectType>

virtual Real LayeredIntegralBase< UserObjectType >::spatialValue ( const Point & p ) const

inlineoverridevirtual

Given a Point return the integral value associated with the layer that point falls in.

Parameters

p	The point to look for in the layers.

Definition at line 32 of file LayeredIntegralBase.h.

32 { return integralValue(p); }

LayeredBase::integralValue

virtual Real integralValue(const Point &p) const

Given a Point return the integral value associated with the layer that point falls in...

Definition: LayeredBase.C:236

◆ supportsElemSideQpArg()

template<typename UserObjectType>

virtual bool SpatialUserObjectFunctor< UserObjectType >::supportsElemSideQpArg ( ) const

inlinefinaloverrideprotectedvirtualinherited

Whether this functor supports evaluation with ElemSideQpArg.

Implements Moose::FunctorBase< Real >.

Definition at line 46 of file SpatialUserObjectFunctor.h.

46 { return true; }

◆ supportsFaceArg()

template<typename UserObjectType>

virtual bool SpatialUserObjectFunctor< UserObjectType >::supportsFaceArg ( ) const

inlinefinaloverrideprotectedvirtualinherited

Whether this functor supports evaluation with FaceArg.

Implements Moose::FunctorBase< Real >.

Definition at line 45 of file SpatialUserObjectFunctor.h.

45 { return true; }

◆ threadJoin()

template<typename UserObjectType >

void LayeredIntegralBase< UserObjectType >::threadJoin ( const UserObject & y )

overridevirtual

Reimplemented from LayeredBase.

Reimplemented in LayeredAverageBase< BaseType >, LayeredAverageBase< SideIntegralFunctorUserObject >, LayeredAverageBase< SideIntegralVariableUserObject >, LayeredAverageBase< ElementIntegralFunctorUserObject >, and LayeredAverageBase< ElementIntegralVariableUserObject >.

Definition at line 93 of file LayeredIntegralBase.h.

Referenced by LayeredAverageBase< ElementIntegralVariableUserObject >::threadJoin().

 {
   UserObjectType::threadJoin(y);
   LayeredBase::threadJoin(y);
 }

◆ timestepSetup()

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

overridevirtualinherited

Implements Moose::FunctorAbstract.

Reimplemented in Function, NumNonlinearIterations, and MemoryUsage.

Definition at line 821 of file MooseFunctor.h.

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

◆ validParams()

template<typename UserObjectType >

InputParameters LayeredIntegralBase< UserObjectType >::validParams ( )

static

Definition at line 48 of file LayeredIntegralBase.h.

Referenced by LayeredAverageBase< ElementIntegralVariableUserObject >::validParams(), LayeredSideIntegralFunctor::validParams(), LayeredIntegralFunctor::validParams(), LayeredSideIntegral::validParams(), and LayeredIntegral::validParams().

 {
   InputParameters params = SpatialUserObjectFunctor<UserObjectType>::validParams();
   params += LayeredBase::validParams();
   return params;
 }

Member Data Documentation

◆ _average_radius

unsigned int LayeredBase::_average_radius

protectedinherited

How many layers both above and below the found layer will be used in the average.

Definition at line 127 of file LayeredBase.h.

Referenced by LayeredBase::integralValue().

◆ _cumulative

bool LayeredBase::_cumulative

protectedinherited

Whether the values are cumulative over the layers.

Definition at line 145 of file LayeredBase.h.

Referenced by LayeredExtremumMaterialProperty::finalize(), LayeredBase::finalize(), and LayeredBase::LayeredBase().

◆ _direction

unsigned int LayeredBase::_direction

protectedinherited

The component direction the layers are going in. We cache this for speed (so we're not always going through the MooseEnum)

Definition at line 112 of file LayeredBase.h.

Referenced by LayeredBase::direction(), LayeredBase::getBounds(), LayeredBase::getLayer(), LayeredBase::integralValue(), LayeredExtremumMaterialProperty::spatialPoints(), and FunctionLayeredIntegral::spatialPoints().

◆ _direction_enum

MooseEnum LayeredBase::_direction_enum

protectedinherited

The MooseEnum direction the layers are going in.

Definition at line 109 of file LayeredBase.h.

◆ _direction_max

Real LayeredBase::_direction_max

protectedinherited

Definition at line 136 of file LayeredBase.h.

Referenced by LayeredBase::computeLayerCenters(), LayeredBase::getBounds(), LayeredBase::getLayer(), LayeredBase::integralValue(), and LayeredBase::LayeredBase().

◆ _direction_min

Real LayeredBase::_direction_min

protectedinherited

Definition at line 135 of file LayeredBase.h.

Referenced by LayeredBase::computeLayerCenters(), LayeredBase::getBounds(), LayeredBase::getLayer(), LayeredBase::integralValue(), and LayeredBase::LayeredBase().

◆ _interval_based

bool LayeredBase::_interval_based

protectedinherited

Whether or not this object is based on equally spaced intervals or "bounds".

Definition at line 115 of file LayeredBase.h.

Referenced by LayeredBase::computeLayerCenters(), LayeredBase::getLayer(), and LayeredBase::LayeredBase().

◆ _layer_bounds

std::vector<Real> LayeredBase::_layer_bounds

protectedinherited

The boundaries of the layers.

Definition at line 121 of file LayeredBase.h.

Referenced by LayeredBase::computeLayerCenters(), LayeredBase::getLayer(), and LayeredBase::LayeredBase().

◆ _layer_centers

std::vector<Real> LayeredBase::_layer_centers

protectedinherited

center coordinates of each layer

Definition at line 133 of file LayeredBase.h.

Referenced by LayeredBase::computeLayerCenters(), LayeredBase::getLayerCenters(), LayeredExtremumMaterialProperty::spatialPoints(), and FunctionLayeredIntegral::spatialPoints().

◆ _layer_has_value

std::vector<int>& LayeredBase::_layer_has_value

protectedinherited

Whether or not each layer has had any value summed into it.

Definition at line 142 of file LayeredBase.h.

Referenced by LayeredExtremumMaterialProperty::finalize(), LayeredBase::finalize(), LayeredBase::initialize(), LayeredBase::integralValue(), LayeredBase::LayeredBase(), LayeredBase::layerHasValue(), and LayeredBase::setLayerValue().

◆ _layer_values

std::vector<Real>& LayeredBase::_layer_values

protectedinherited

Value of the integral for each layer.

Definition at line 139 of file LayeredBase.h.

Referenced by LayeredExtremumMaterialProperty::finalize(), LayeredBase::finalize(), LayeredBase::getLayerValue(), LayeredBase::initialize(), LayeredBase::integralValue(), LayeredBase::LayeredBase(), LayeredBase::setLayerValue(), and LayeredBase::threadJoin().

◆ _layered_base_name

std::string LayeredBase::_layered_base_name

protectedinherited

Name of this object.

Definition at line 103 of file LayeredBase.h.

Referenced by LayeredBase::getLayerValue().

◆ _layered_base_params

const InputParameters& LayeredBase::_layered_base_params

protectedinherited

Params for this object.

Definition at line 106 of file LayeredBase.h.

Referenced by LayeredBase::LayeredBase().

◆ _num_layers

unsigned int LayeredBase::_num_layers

protectedinherited

Number of layers to split the mesh into.

Definition at line 118 of file LayeredBase.h.

Referenced by LayeredBase::computeLayerCenters(), LayeredExtremumMaterialProperty::finalize(), LayeredBase::finalize(), LayeredBase::getLayer(), LayeredExtremumMaterialProperty::initialize(), LayeredBase::integralValue(), LayeredAverageBase< ElementIntegralVariableUserObject >::LayeredAverageBase(), LayeredBase::LayeredBase(), and LayeredExtremumMaterialProperty::threadJoin().

◆ _positive_cumulative_direction

const bool LayeredBase::_positive_cumulative_direction

protectedinherited

Whether the cumulative values should be summed in the positive or negative direction.

Definition at line 148 of file LayeredBase.h.

Referenced by LayeredExtremumMaterialProperty::finalize(), and LayeredBase::finalize().

◆ _sample_type

unsigned int LayeredBase::_sample_type

protectedinherited

How to sample the values.

Definition at line 124 of file LayeredBase.h.

Referenced by LayeredBase::integralValue(), and LayeredBase::LayeredBase().

◆ _using_displaced_mesh

bool LayeredBase::_using_displaced_mesh

protectedinherited

true if this object operates on the displaced mesh, otherwise false

Definition at line 130 of file LayeredBase.h.

Referenced by LayeredBase::initialize().

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

include/userobjects/LayeredIntegralBase.h

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

template<typename UserObjectType> class LayeredIntegralBase< UserObjectType >

Member Typedef Documentation

◆ DotType

◆ ElemArg

◆ ElemPointArg

◆ ElemQpArg

◆ ElemSideQpArg

◆ FaceArg

◆ FunctorType

◆ GradientType

◆ NodeArg

◆ ValueType

Constructor & Destructor Documentation

◆ LayeredIntegralBase()

Member Function Documentation

◆ checkFace()

◆ computeLayerCenters()

◆ customSetup()

◆ direction()

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

◆ evaluateTemplate()

◆ execute()

◆ finalize()

◆ functorName()

◆ genericEvaluate()

◆ getBounds()

◆ getLayer()

◆ getLayerCenters()

◆ getLayerValue()

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

◆ initialize()

template<typename UserObjectType>
class LayeredIntegralBase< UserObjectType >