This UserObject computes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z). More...

#include <NearestPointBase.h>

Inheritance diagram for NearestPointBase< UserObjectType, BaseType >:

[legend]

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
	NearestPointBase (const InputParameters &parameters)

	~NearestPointBase ()

virtual void	initialize () override

virtual void	execute () override

virtual void	finalize () override

virtual void	threadJoin (const UserObject &y) override

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

virtual const std::vector< Point > &	getPoints () const
	Get the points at which the nearest operation is performed. More...

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

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

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


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
void	fillPoints ()
	Fills in the `_points` variable from either 'points' or 'points_file' parameter. More...

UserObjectType &	nearestUserObject (const Point &p) const
	Get the UserObject that is closest to the point. More...

const std::string &	name () const
	Get the name of the class. More...

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

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::vector< Point >	_points

std::vector< std::unique_ptr< UserObjectType > >	_user_objects

const unsigned int	_dist_norm

const unsigned int	_axis

Detailed Description

template<typename UserObjectType, typename BaseType>
class NearestPointBase< UserObjectType, BaseType >

This UserObject computes averages of a variable storing partial sums for the specified number of intervals in a direction (x,y,z).

Given a list of points this object computes the layered average closest to each one of those points.

Definition at line 31 of file NearestPointBase.h.

Member Typedef Documentation

◆ DotType

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

inherited

Definition at line 150 of file MooseFunctor.h.

◆ ElemArg

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

protectedinherited

Definition at line 29 of file SpatialUserObjectFunctor.h.

◆ ElemPointArg

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

protectedinherited

Definition at line 33 of file SpatialUserObjectFunctor.h.

◆ ElemQpArg

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

protectedinherited

Definition at line 30 of file SpatialUserObjectFunctor.h.

◆ ElemSideQpArg

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

protectedinherited

Definition at line 31 of file SpatialUserObjectFunctor.h.

◆ FaceArg

using SpatialUserObjectFunctor< BaseType >::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

using SpatialUserObjectFunctor< BaseType >::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

◆ NearestPointBase()

template<typename UserObjectType , typename BaseType >

NearestPointBase< UserObjectType, BaseType >::NearestPointBase ( const InputParameters & parameters )

Definition at line 125 of file NearestPointBase.h.

   : SpatialUserObjectFunctor<BaseType>(parameters),
     _dist_norm(this->template getParam<MooseEnum>("dist_norm")),
     _axis(this->template getParam<MooseEnum>("axis"))
 {
   if (this->template getParam<MooseEnum>("dist_norm") != "radius" &&
       parameters.isParamSetByUser("axis"))
     this->paramError("axis", "'axis' should only be set if 'dist_norm' is set to 'radius'");
 
   fillPoints();
 
   _user_objects.resize(_points.size());
 
   // Build each of the UserObject objects that we will manage manually
   // If you're looking at this in the future and want to replace this behavior,
   // _please_ don't do it. MOOSE should manage these objects.
   for (MooseIndex(_points) i = 0; i < _points.size(); ++i)
   {
     const auto uo_type = MooseUtils::prettyCppType<UserObjectType>();
     auto sub_params = this->_app.getFactory().getValidParams(uo_type);
     sub_params.applyParameters(parameters, {}, true);
 
     const auto sub_name = name() + "_sub" + std::to_string(i);
     auto uo = this->_app.getFactory().template createUnique<UserObjectType>(
         uo_type, sub_name, sub_params, this->_tid);
     _user_objects[i] = std::move(uo);
   }
 }

◆ ~NearestPointBase()

template<typename UserObjectType , typename BaseType >

NearestPointBase< UserObjectType, BaseType >::~NearestPointBase ( )

Definition at line 155 of file NearestPointBase.h.

156 {

157 }

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

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

◆ customSetup()

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

overridevirtualinherited

Implements Moose::FunctorAbstract.

Reimplemented in Function.

Definition at line 839 of file MooseFunctor.h.

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

◆ 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 890 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 897 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 905 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 912 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 919 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 926 of file MooseFunctor.h.

 {
   return evaluateDot(node, state);
 }

◆ evaluate() [1/6]

Real SpatialUserObjectFunctor< BaseType >::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]

Real SpatialUserObjectFunctor< BaseType >::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]

Real SpatialUserObjectFunctor< BaseType >::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]

Real SpatialUserObjectFunctor< BaseType >::evaluate	(	const ElemSideQpArg &	elem_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]

Real SpatialUserObjectFunctor< BaseType >::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]

Real SpatialUserObjectFunctor< BaseType >::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 385 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 395 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 405 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 416 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 425 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 430 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 439 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 449 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 459 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 470 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 479 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 484 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 332 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 342 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 352 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 362 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 371 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 376 of file MooseFunctor.h.

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

◆ evaluateTemplate()

Real SpatialUserObjectFunctor< BaseType >::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 , typename BaseType >

void NearestPointBase< UserObjectType, BaseType >::execute ( )

overridevirtual

Definition at line 205 of file NearestPointBase.h.

 {
   nearestUserObject(_current_elem->vertex_average()).execute();
 }

◆ fillPoints()

template<typename UserObjectType , typename BaseType >

void NearestPointBase< UserObjectType, BaseType >::fillPoints ( )

protected

Fills in the _points variable from either 'points' or 'points_file' parameter.

Also performs error checking.

Definition at line 161 of file NearestPointBase.h.

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

 {
   if (isParamValid("points"))
   {
     _points = this->template getParam<std::vector<Point>>("points");
     if (isParamValid("points_file"))
       this->paramError("points_file", "Cannot be specified together with 'points'");
     if (isParamValid("positions_object"))
       this->paramError("positions_object", "Cannot be specified together with 'points'");
   }
   else if (isParamValid("points_file"))
   {
     const FileName & points_file = this->template getParam<FileName>("points_file");
 
     MooseUtils::DelimitedFileReader file(points_file, &_communicator);
     file.setFormatFlag(MooseUtils::DelimitedFileReader::FormatFlag::ROWS);
     file.read();
     _points = file.getDataAsPoints();
 
     if (isParamValid("positions_object"))
       this->paramError("positions_object", "Cannot be specified together with 'points_file'");
   }
   else if (isParamValid("positions_object"))
   {
     const auto & positions_name = this->template getParam<PositionsName>("positions_object");
     const auto problem = this->template getCheckedPointerParam<FEProblemBase *>("_fe_problem_base");
     _points = problem->getPositionsObject(positions_name).getPositions(/*initial_positions*/ true);
   }
   else
     mooseError(
         name(),
         ": You need to supply either 'points', 'points_file' or 'positions_object' parameter.");
 }

◆ finalize()

template<typename UserObjectType , typename BaseType >

void NearestPointBase< UserObjectType, BaseType >::finalize ( )

overridevirtual

Reimplemented in NearestPointAverage, and NearestPointIntegralVariablePostprocessor.

Definition at line 212 of file NearestPointBase.h.

 {
   for (auto & user_object : _user_objects)
     user_object->finalize();
 }

◆ functorName()

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

inlineinherited

Return the functor name.

Definition at line 170 of file MooseFunctor.h.

170 { return _functor_name; }

Moose::FunctorBase< Real >::_functor_name

MooseFunctorName _functor_name

name of the functor

Definition: MooseFunctor.h:564

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

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

◆ getPoints()

template<typename UserObjectType, typename BaseType>

virtual const std::vector<Point>& NearestPointBase< UserObjectType, BaseType >::getPoints ( ) const

inlinevirtual

Get the points at which the nearest operation is performed.

Returns: points

Definition at line 57 of file NearestPointBase.h.

57 { return _points; }

NearestPointBase::_points

std::vector< Point > _points

Definition: NearestPointBase.h:76

◆ 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 933 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 940 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 948 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 955 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 962 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 969 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 847 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 854 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 862 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 869 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 876 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 883 of file MooseFunctor.h.

 {
   return evaluateGradient(node, state);
 }

◆ hasBlocks()

bool SpatialUserObjectFunctor< BaseType >::hasBlocks ( SubdomainID sub ) const

overridevirtualinherited

Returns whether the functor is defined on this block.

Reimplemented from Moose::FunctorBase< Real >.

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 976 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 , typename BaseType >

void NearestPointBase< UserObjectType, BaseType >::initialize ( )

overridevirtual

Definition at line 197 of file NearestPointBase.h.

 {
   for (auto & user_object : _user_objects)
     user_object->initialize();
 }

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

260 { 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 247 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 569 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 831 of file MooseFunctor.h.

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

◆ name()

template<typename UserObjectType, typename BaseType>

const std::string& MooseBase::name

inlineprotected

Get the name of the class.

Returns: The name of the class

Definition at line 99 of file MooseBase.h.

   {
     mooseAssert(_name.size(), "Empty name");
     return _name;
   }

◆ nearestUserObject()

template<typename UserObjectType , typename BaseType >

UserObjectType & NearestPointBase< UserObjectType, BaseType >::nearestUserObject ( const Point & p ) const

protected

Get the UserObject that is closest to the point.

Parameters

p	The point.

Returns: The UserObject closest to p.

Definition at line 237 of file NearestPointBase.h.

 {
   unsigned int closest = 0;
   Real closest_distance = std::numeric_limits<Real>::max();
 
   for (auto it : Moose::enumerate(_points))
   {
     const auto & current_point = it.value();
 
     Real current_distance;
     if (_dist_norm == 0)
       // the distance is computed using standard norm
       current_distance = (p - current_point).norm();
     else
     {
       // the distance is to be computed based on radii
       // in that case, we need to determine the 2 coordinate indices
       // that define the radius
       unsigned int i = 0;
       unsigned int j = 1;
 
       if (_axis == 0)
         i = 2;
       else if (_axis == 1)
         j = 2;
 
       current_distance = std::abs(
           std::sqrt(p(i) * p(i) + p(j) * p(j)) -
           std::sqrt(current_point(i) * current_point(i) + current_point(j) * current_point(j)));
     }
 
     if (current_distance < closest_distance)
     {
       closest_distance = current_distance;
       closest = it.index();
     }
   }
 
   return *_user_objects[closest];
 }

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

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

◆ operator()() [2/6]

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

inherited

Definition at line 610 of file MooseFunctor.h.

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

◆ operator()() [3/6]

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

inherited

Definition at line 656 of file MooseFunctor.h.

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

◆ operator()() [4/6]

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

inherited

Definition at line 677 of file MooseFunctor.h.

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

◆ operator()() [5/6]

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

inherited

Definition at line 707 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 724 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 823 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 714 of file MooseFunctor.h.

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

◆ spatialPoints()

template<typename UserObjectType , typename BaseType >

const std::vector< Point > NearestPointBase< UserObjectType, BaseType >::spatialPoints ( ) const

overridevirtual

Reimplemented in NearestPointIntegralVariablePostprocessor.

Definition at line 280 of file NearestPointBase.h.

 {
   std::vector<Point> points;
 
   for (MooseIndex(_points) i = 0; i < _points.size(); ++i)
   {
     auto layered_base = dynamic_cast<LayeredBase *>(_user_objects[i].get());
     if (layered_base)
     {
       const auto & layers = layered_base->getLayerCenters();
       auto direction = layered_base->direction();
 
       for (const auto & l : layers)
       {
         Point pt = _points[i];
         pt(direction) = l;
         points.push_back(pt);
       }
     }
   }
 
   return points;
 }

◆ spatialValue()

template<typename UserObjectType , typename BaseType >

Real NearestPointBase< UserObjectType, BaseType >::spatialValue ( const Point & p ) const

overridevirtual

Given a Point return the integral value associated with the layer that point falls in for the layered average closest to that point.

Parameters

p	The point to look for in the layers.

Reimplemented in NearestPointAverage, and NearestPointIntegralVariablePostprocessor.

Definition at line 230 of file NearestPointBase.h.

 {
   return nearestUserObject(p).spatialValue(p);
 }

◆ supportsElemSideQpArg()

virtual bool SpatialUserObjectFunctor< BaseType >::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()

virtual bool SpatialUserObjectFunctor< BaseType >::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 , typename BaseType >

void NearestPointBase< UserObjectType, BaseType >::threadJoin ( const UserObject & y )

overridevirtual

Definition at line 220 of file NearestPointBase.h.

 {
   auto & npla = static_cast<const NearestPointBase &>(y);
 
   for (MooseIndex(_user_objects) i = 0; i < _user_objects.size(); ++i)
     _user_objects[i]->threadJoin(*npla._user_objects[i]);
 }

◆ timestepSetup()

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

overridevirtualinherited

Implements Moose::FunctorAbstract.

Reimplemented in Function, NumNonlinearIterations, and MemoryUsage.

Definition at line 815 of file MooseFunctor.h.

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

◆ validParams()

template<typename UserObjectType , typename BaseType >

InputParameters NearestPointBase< UserObjectType, BaseType >::validParams ( )

static

Definition at line 93 of file NearestPointBase.h.

Referenced by NearestPointLayeredSideAverageFunctor::validParams(), NearestPointLayeredSideIntegralFunctor::validParams(), NearestPointAverage::validParams(), NearestPointLayeredSideIntegral::validParams(), NearestPointLayeredAverage::validParams(), NearestPointLayeredSideAverage::validParams(), NearestPointLayeredIntegral::validParams(), and NearestRadiusLayeredAverage::validParams().

 {
   InputParameters params = SpatialUserObjectFunctor<BaseType>::validParams();
 
   params.addParam<std::vector<Point>>("points",
                                       "Computations will be lumped into values at these points.");
   params.addParam<FileName>("points_file",
                             "A filename that should be looked in for points. Each "
                             "set of 3 values in that file will represent a Point. "
                             "This and 'points' cannot be both supplied.");
   params.addParam<PositionsName>(
       "positions_object",
       "The name of a Positions object that will contain "
       "the locations. This, 'points' and 'points(_file)' cannot be both supplied. "
       "Note that only the vector of initial Positions are used at this time. "
       "Updates to the 'positions' vector are not supported.");
 
   MooseEnum distnorm("point=0 radius=1", "point");
   params.addParam<MooseEnum>(
       "dist_norm", distnorm, "To specify whether the distance is defined based on point or radius");
   MooseEnum axis("x=0 y=1 z=2", "z");
   params.addParam<MooseEnum>("axis", axis, "The axis around which the radius is determined");
 
   params.addParamNamesToGroup("points points_file dist_norm axis", "Points and distance to points");
 
   // Add in the valid parameters
   params += UserObjectType::validParams();
 
   return params;
 }

Member Data Documentation

◆ _axis

template<typename UserObjectType, typename BaseType>

const unsigned int NearestPointBase< UserObjectType, BaseType >::_axis

protected

Definition at line 82 of file NearestPointBase.h.

◆ _dist_norm

template<typename UserObjectType, typename BaseType>

const unsigned int NearestPointBase< UserObjectType, BaseType >::_dist_norm

protected

Definition at line 80 of file NearestPointBase.h.

◆ _points

template<typename UserObjectType, typename BaseType>

std::vector<Point> NearestPointBase< UserObjectType, BaseType >::_points

protected

Definition at line 76 of file NearestPointBase.h.

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

◆ _user_objects

template<typename UserObjectType, typename BaseType>

std::vector<std::unique_ptr<UserObjectType> > NearestPointBase< UserObjectType, BaseType >::_user_objects

protected

Definition at line 77 of file NearestPointBase.h.

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

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

include/userobjects/NearestPointBase.h

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Detailed Description

template<typename UserObjectType, typename BaseType> class NearestPointBase< UserObjectType, BaseType >

Member Typedef Documentation

◆ DotType

◆ ElemArg

◆ ElemPointArg

◆ ElemQpArg

◆ ElemSideQpArg

◆ FaceArg

◆ FunctorType

◆ GradientType

◆ NodeArg

◆ ValueType

Constructor & Destructor Documentation

◆ NearestPointBase()

◆ ~NearestPointBase()

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]

◆ evaluateTemplate()

◆ execute()

◆ fillPoints()

◆ finalize()

◆ functorName()

◆ genericEvaluate()

◆ getPoints()

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

◆ isConstant()

◆ isExtrapolatedBoundaryFace()

◆ isInternalFace()

template<typename UserObjectType, typename BaseType>
class NearestPointBase< UserObjectType, BaseType >