https://mooseframework.inl.gov
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Private Member Functions | Private Attributes | List of all members
NearestRadiusLayeredAverage Class Reference

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

#include <NearestRadiusLayeredAverage.h>

Inheritance diagram for NearestRadiusLayeredAverage:
[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).
 
using DotType = ValueType
 

Public Member Functions

 NearestRadiusLayeredAverage (const InputParameters &parameters)
 
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.
 
virtual const std::vector< Point > & getPoints () const
 Get the points at which the nearest operation is performed.
 
virtual const std::vector< Point > spatialPoints () const override
 
virtual bool hasBlocks (SubdomainID sub) const override
 Returns whether the functor is defined on this block.
 
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.
 
const MooseFunctorName & functorName () const
 Return the functor name.
 
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.
 
virtual bool isExtrapolatedBoundaryFace (const FaceInfo &, const Elem *, const StateArg &) const
 Returns whether this (sided) face is an extrapolated boundary face for this functor.
 
bool isInternalFace (const FaceInfo &) const
 Returns true if the face is an internal face.
 
virtual bool isConstant () const
 Returns true if this functor is a constant.
 
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.
 
ValueType operator() (const ElemArg &elem, const StateArg &state) const
 Same as their evaluate overloads with the same arguments but allows for caching implementation.
 
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.
 
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.
 
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.
 
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.
 
LayeredAverage & nearestUserObject (const Point &p) const
 Get the UserObject that is closest to the point.
 
const std::string & name () const
 Get the name of the class.
 
virtual Real evaluate (const ElemArg &elem, const Moose::StateArg &state) const override
 Evaluate the functor with a given element.
 
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.
 
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.
 
virtual bool supportsElemSideQpArg () const override final
 Whether this functor supports evaluation with ElemSideQpArg.
 
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.
 
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.
 
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.
 
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.
 
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.
 
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.
 
virtual GradientType evaluateGradDot (const NodeArg &, const StateArg &) const
 

Protected Attributes

std::vector< Point > _points
 
std::vector< std::unique_ptr< LayeredAverage > > _user_objects
 
const unsigned int _dist_norm
 
const unsigned int _axis
 

Private Member Functions

template<typename SpatialArg >
Real evaluateTemplate (const SpatialArg &position, const Moose::StateArg &state) const
 
void clearCacheData ()
 clear cache data
 
ValueType queryQpCache (unsigned int qp, const libMesh::QBase &qrule, std::vector< std::pair< bool, Real > > &qp_cache_data, const SpaceArg &space, const StateArg &state) const
 check a qp cache and if invalid then evaluate
 
ValueType queryFVArgCache (std::map< SpaceArg, ValueType > &cache_data, const SpaceArg &space) const
 check a finite volume spatial argument cache and if invalid then evaluate
 

Private Attributes

std::set< ExecFlagType > _clearance_schedule
 How often to clear the material property cache.
 
bool _always_evaluate
 Boolean to check if we always need evaluation.
 
dof_id_type _current_qp_map_key
 Current key for qp map cache.
 
std::vector< std::pair< bool, ValueType > > * _current_qp_map_value
 Current value for qp map cache.
 
std::unordered_map< dof_id_type, std::vector< std::pair< bool, ValueType > > > _qp_to_value
 Cached element quadrature point functor property evaluations.
 
dof_id_type _current_side_qp_map_key
 Current key for side-qp map cache.
 
std::vector< std::vector< std::pair< bool, ValueType > > > * _current_side_qp_map_value
 Current value for side-qp map cache.
 
std::unordered_map< dof_id_type, std::vector< std::vector< std::pair< bool, ValueType > > > > _side_qp_to_value
 Cached element quadrature point functor property evaluations.
 
std::map< ElemArg, ValueType > _elem_arg_to_value
 Map from element arguments to their cached evaluations.
 
std::map< FaceArg, ValueType > _face_arg_to_value
 Map from face arguments to their cached evaluations.
 
std::map< NodeArg, ValueType > _node_arg_to_value
 Map from nodal arguments to their cached evaluations.
 
MooseFunctorName _functor_name
 name of the functor
 

Detailed Description

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, where the distance is computed in terms of radius (or distance to the origin in the plane perpendicular to 'direction')

Definition at line 25 of file NearestRadiusLayeredAverage.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

◆ NearestRadiusLayeredAverage()

NearestRadiusLayeredAverage::NearestRadiusLayeredAverage ( const InputParameters &  parameters)

Definition at line 39 of file NearestRadiusLayeredAverage.C.

40 : NearestPointBase<LayeredAverage, ElementIntegralVariableUserObject>(parameters)
41{
42}
NearestPointBase
This UserObject computes averages of a variable storing partial sums for the specified number of inte...
Definition NearestPointBase.h:32

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 \emph has indicated a sidedness and we are not defined on that side, then we will error

Parameters
faceThe face argument created by the face argument producer, likely a residual object
Returns
A face with possibly changed sidedness depending on whether we aren't defined on both sides of the face

Definition at line 280 of file MooseFunctor.h.

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

◆ clearCacheData()

void Moose::FunctorBase< Real >::clearCacheData ( )
privateinherited

clear cache data

Definition at line 500 of file MooseFunctor.h.

796{
797 for (auto & map_pr : _qp_to_value)
798 for (auto & pr : map_pr.second)
799 pr.first = false;
800
801 for (auto & map_pr : _side_qp_to_value)
802 {
803 auto & side_vector = map_pr.second;
804 for (auto & qp_vector : side_vector)
805 for (auto & pr : qp_vector)
806 pr.first = false;
807 }
808
809 _current_qp_map_key = libMesh::DofObject::invalid_id;
810 _current_qp_map_value = nullptr;
811 _current_side_qp_map_key = libMesh::DofObject::invalid_id;
812 _current_side_qp_map_value = nullptr;
813
814 _elem_arg_to_value.clear();
815 _face_arg_to_value.clear();
816 _node_arg_to_value.clear();
817}
for
for(PetscInt i=0;i< nvars;++i)
Definition PetscDMMoose.C:1721
Moose::FunctorBase< Real >::_current_qp_map_key
dof_id_type _current_qp_map_key
Current key for qp map cache.
Definition MooseFunctor.h:529
Moose::FunctorBase< Real >::_elem_arg_to_value
std::map< ElemArg, ValueType > _elem_arg_to_value
Map from element arguments to their cached evaluations.
Definition MooseFunctor.h:561
Moose::FunctorBase< Real >::_qp_to_value
std::unordered_map< dof_id_type, std::vector< std::pair< bool, ValueType > > > _qp_to_value
Cached element quadrature point functor property evaluations.
Definition MooseFunctor.h:539
Moose::FunctorBase< Real >::_face_arg_to_value
std::map< FaceArg, ValueType > _face_arg_to_value
Map from face arguments to their cached evaluations.
Definition MooseFunctor.h:564
Moose::FunctorBase< Real >::_current_side_qp_map_value
std::vector< std::vector< std::pair< bool, ValueType > > > * _current_side_qp_map_value
Current value for side-qp map cache.
Definition MooseFunctor.h:548
Moose::FunctorBase< Real >::_node_arg_to_value
std::map< NodeArg, ValueType > _node_arg_to_value
Map from nodal arguments to their cached evaluations.
Definition MooseFunctor.h:567
Moose::FunctorBase< Real >::_current_qp_map_value
std::vector< std::pair< bool, ValueType > > * _current_qp_map_value
Current value for qp map cache.
Definition MooseFunctor.h:532
Moose::FunctorBase< Real >::_current_side_qp_map_key
dof_id_type _current_side_qp_map_key
Current key for side-qp map cache.
Definition MooseFunctor.h:545
Moose::FunctorBase< Real >::_side_qp_to_value
std::unordered_map< dof_id_type, std::vector< std::vector< std::pair< bool, ValueType > > > > _side_qp_to_value
Cached element quadrature point functor property evaluations.
Definition MooseFunctor.h:558
libMesh::DofObject::invalid_id
static constexpr dof_id_type invalid_id

◆ customSetup()

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

Implements Moose::FunctorAbstract.

Reimplemented in Function.

Definition at line 233 of file MooseFunctor.h.

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

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

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

◆ dot() [2/6]

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

Definition at line 213 of file MooseFunctor.h.

926{
927 return evaluateDot(elem_point, state);
928}

◆ dot() [3/6]

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

Definition at line 211 of file MooseFunctor.h.

912{
913 return evaluateDot(elem_qp, state);
914}

◆ dot() [4/6]

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

Definition at line 212 of file MooseFunctor.h.

919{
920 return evaluateDot(elem_side_qp, state);
921}

◆ dot() [5/6]

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

Definition at line 210 of file MooseFunctor.h.

904{
905 checkFace(face);
906 return evaluateDot(face, state);
907}
Moose::FunctorBase< Real >::checkFace
void checkFace(const Moose::FaceArg &face) const
Examines the incoming face argument.
Definition MooseFunctor.h:738

◆ dot() [6/6]

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

Definition at line 214 of file MooseFunctor.h.

933{
934 return evaluateDot(node, state);
935}

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

Reimplemented in ExtraIDIntegralVectorPostprocessor.

Definition at line 85 of file SpatialUserObjectFunctor.h.

87{
88 return evaluateTemplate(elem, state);
89}
SpatialUserObjectFunctor::evaluateTemplate
Real evaluateTemplate(const SpatialArg &position, const Moose::StateArg &state) const

◆ evaluate() [2/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.

119{
120 return evaluateTemplate(elem_point, state);
121}

◆ evaluate() [3/6]

template<typename UserObjectType >
Real SpatialUserObjectFunctor< UserObjectType >::evaluate ( const ElemQpArg &  qp,
const Moose::StateArg &  state 
) const
overrideprotectedvirtualinherited
Parameters
qpSee the ElemQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor evaluated at the requested state and space

Implements Moose::FunctorBase< Real >.

Reimplemented in ExtraIDIntegralVectorPostprocessor.

Definition at line 101 of file SpatialUserObjectFunctor.h.

103{
104 return evaluateTemplate(qp, state);
105}

◆ evaluate() [4/6]

template<typename UserObjectType >
Real SpatialUserObjectFunctor< UserObjectType >::evaluate ( const ElemSideQpArg &  side_qp,
const Moose::StateArg &  state 
) const
finaloverrideprotectedvirtualinherited
Parameters
side_qpSee the ElemSideQpArg doxygen
stateSee 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.

111{
112 return evaluateTemplate(elem_side_qp, state);
113}

◆ evaluate() [5/6]

template<typename UserObjectType >
Real SpatialUserObjectFunctor< UserObjectType >::evaluate ( const FaceArg &  face,
const Moose::StateArg &  state 
) const
finaloverrideprotectedvirtualinherited
Parameters
faceSee the FaceArg doxygen
stateSee 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.

95{
96 return evaluateTemplate(face, state);
97}

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

127{
128 return evaluateTemplate(node, state);
129}

◆ 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 Function, and Postprocessor.

Definition at line 391 of file MooseFunctor.h.

392 {
393 mooseError("Element time derivative not implemented for functor " + functorName());
394 }
Moose::FunctorBase< Real >::functorName
const MooseFunctorName & functorName() const
Return the functor name.
Definition MooseFunctor.h:176

◆ evaluateDot() [2/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 Function, and Postprocessor.

Definition at line 431 of file MooseFunctor.h.

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

◆ evaluateDot() [3/6]

virtual DotType Moose::FunctorBase< Real >::evaluateDot ( const ElemQpArg &  ,
const StateArg &   
) const
inlineprotectedvirtualinherited
Parameters
qpSee the ElemQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor time derivative evaluated at the requested state and space

Reimplemented in Function, and Postprocessor.

Definition at line 411 of file MooseFunctor.h.

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

◆ evaluateDot() [4/6]

virtual DotType Moose::FunctorBase< Real >::evaluateDot ( const ElemSideQpArg &  ,
const StateArg &   
) const
inlineprotectedvirtualinherited
Parameters
side_qpSee the ElemSideQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor time derivative evaluated at the requested state and space

Reimplemented in Function, and Postprocessor.

Definition at line 422 of file MooseFunctor.h.

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

◆ evaluateDot() [5/6]

virtual DotType Moose::FunctorBase< Real >::evaluateDot ( const FaceArg &  ,
const StateArg &   
) const
inlineprotectedvirtualinherited
Parameters
faceSee the FaceArg doxygen
stateSee the StateArg doxygen
Returns
The functor time derivative evaluated at the requested state and space

Reimplemented in Function, and Postprocessor.

Definition at line 401 of file MooseFunctor.h.

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

◆ evaluateDot() [6/6]

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

Reimplemented in Function, and Postprocessor.

Definition at line 436 of file MooseFunctor.h.

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

◆ 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

Definition at line 445 of file MooseFunctor.h.

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

◆ evaluateGradDot() [2/6]

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

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

Definition at line 485 of file MooseFunctor.h.

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

◆ evaluateGradDot() [3/6]

virtual GradientType Moose::FunctorBase< Real >::evaluateGradDot ( const ElemQpArg &  ,
const StateArg &   
) const
inlineprotectedvirtualinherited
Parameters
qpSee the ElemQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor gradient-dot evaluated at the requested state and space

Definition at line 465 of file MooseFunctor.h.

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

◆ evaluateGradDot() [4/6]

virtual GradientType Moose::FunctorBase< Real >::evaluateGradDot ( const ElemSideQpArg &  ,
const StateArg &   
) const
inlineprotectedvirtualinherited
Parameters
side_qpSee the ElemSideQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor gradient-dot evaluated at the requested state and space

Definition at line 476 of file MooseFunctor.h.

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

◆ evaluateGradDot() [5/6]

virtual GradientType Moose::FunctorBase< Real >::evaluateGradDot ( const FaceArg &  ,
const StateArg &   
) const
inlineprotectedvirtualinherited
Parameters
faceSee the FaceArg doxygen
stateSee the StateArg doxygen
Returns
The functor gradient-dot evaluated at the requested state and space

Definition at line 455 of file MooseFunctor.h.

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

◆ evaluateGradDot() [6/6]

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

Definition at line 490 of file MooseFunctor.h.

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

◆ 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 Function, and Postprocessor.

Definition at line 338 of file MooseFunctor.h.

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

◆ evaluateGradient() [2/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 Function, and Postprocessor.

Definition at line 377 of file MooseFunctor.h.

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

◆ evaluateGradient() [3/6]

virtual GradientType Moose::FunctorBase< Real >::evaluateGradient ( const ElemQpArg &  ,
const StateArg &   
) const
inlineprotectedvirtualinherited
Parameters
qpSee the ElemQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor gradient evaluated at the requested state and space

Reimplemented in Function, and Postprocessor.

Definition at line 358 of file MooseFunctor.h.

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

◆ evaluateGradient() [4/6]

virtual GradientType Moose::FunctorBase< Real >::evaluateGradient ( const ElemSideQpArg &  ,
const StateArg &   
) const
inlineprotectedvirtualinherited
Parameters
side_qpSee the ElemSideQpArg doxygen
stateSee the StateArg doxygen
Returns
The functor gradient evaluated at the requested state and space

Reimplemented in Function, and Postprocessor.

Definition at line 368 of file MooseFunctor.h.

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

◆ evaluateGradient() [5/6]

virtual GradientType Moose::FunctorBase< Real >::evaluateGradient ( const FaceArg &  ,
const StateArg &   
) const
inlineprotectedvirtualinherited
Parameters
faceSee the FaceArg doxygen
stateSee the StateArg doxygen
Returns
The functor gradient evaluated at the requested state and space

Reimplemented in Function, and Postprocessor.

Definition at line 348 of file MooseFunctor.h.

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

◆ evaluateGradient() [6/6]

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

Reimplemented in Function, and Postprocessor.

Definition at line 382 of file MooseFunctor.h.

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

◆ evaluateTemplate() [1/2]

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.

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

◆ evaluateTemplate() [2/2]

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

◆ execute()

void NearestPointBase< LayeredAverage , ElementIntegralVariableUserObject >::execute ( )
overridevirtualinherited

Definition at line 40 of file NearestPointBase.h.

206{
207 nearestUserObject(_current_elem->vertex_average()).execute();
208}
LayeredAverageBase::execute
virtual void execute() override
Definition LayeredAverageBase.h:77
NearestPointBase< LayeredAverage, ElementIntegralVariableUserObject >::nearestUserObject
LayeredAverage & nearestUserObject(const Point &p) const
Get the UserObject that is closest to the point.
Definition NearestPointBase.h:237

◆ fillPoints()

void NearestPointBase< LayeredAverage , ElementIntegralVariableUserObject >::fillPoints ( )
protectedinherited

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

Also performs error checking.

Definition at line 66 of file NearestPointBase.h.

162{
163 if (isParamValid("points"))
164 {
165 _points = this->template getParam<std::vector<Point>>("points");
166 if (isParamValid("points_file"))
167 this->paramError("points_file", "Cannot be specified together with 'points'");
168 if (isParamValid("positions_object"))
169 this->paramError("positions_object", "Cannot be specified together with 'points'");
170 }
171 else if (isParamValid("points_file"))
172 {
173 const FileName & points_file = this->template getParam<FileName>("points_file");
174
175 MooseUtils::DelimitedFileReader file(points_file, &_communicator);
176 file.setFormatFlag(MooseUtils::DelimitedFileReader::FormatFlag::ROWS);
177 file.read();
178 _points = file.getDataAsPoints();
179
180 if (isParamValid("positions_object"))
181 this->paramError("positions_object", "Cannot be specified together with 'points_file'");
182 }
183 else if (isParamValid("positions_object"))
184 {
185 const auto & positions_name = this->template getParam<PositionsName>("positions_object");
186 const auto problem = this->template getCheckedPointerParam<FEProblemBase *>("_fe_problem_base");
187 _points = problem->getPositionsObject(positions_name).getPositions(/*initial_positions*/ true);
188 }
189 else
190 mooseError(
191 name(),
192 ": You need to supply either 'points', 'points_file' or 'positions_object' parameter.");
193}
MooseUtils::DelimitedFileReaderTempl
Utility class for reading delimited data (e.g., CSV data).
Definition DelimitedFileReader.h:37
NearestPointBase< LayeredAverage, ElementIntegralVariableUserObject >::name
const std::string & name() const
Get the name of the class.
Definition MooseBase.h:103

◆ finalize()

void NearestPointBase< LayeredAverage , ElementIntegralVariableUserObject >::finalize ( )
overridevirtualinherited

Definition at line 41 of file NearestPointBase.h.

213{
214 for (auto & user_object : _user_objects)
215 user_object->finalize();
216}
NearestPointBase< LayeredAverage, ElementIntegralVariableUserObject >::_user_objects
std::vector< std::unique_ptr< LayeredAverage > > _user_objects
Definition NearestPointBase.h:77

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

994{
995 if constexpr (FET == FunctorEvaluationKind::Value)
996 return (*this)(r, state);
997 else if constexpr (FET == FunctorEvaluationKind::Gradient)
998 return gradient(r, state);
999 else if constexpr (FET == FunctorEvaluationKind::Dot)
1000 return dot(r, state);
1001 else
1002 return gradDot(r, state);
1003}
Moose::FunctorBase< Real >::dot
DotType dot(const ElemArg &elem, const StateArg &state) const
Same as their evaluateDot overloads with the same arguments but allows for caching implementation.
Definition MooseFunctor.h:896
Moose::FunctorBase< Real >::gradient
GradientType gradient(const ElemArg &elem, const StateArg &state) const
Same as their evaluateGradient overloads with the same arguments but allows for caching implementatio...
Definition MooseFunctor.h:853
Moose::FunctorBase< Real >::gradDot
GradientType gradDot(const ElemArg &elem, const StateArg &state) const
Same as their evaluateGradDot overloads with the same arguments but allows for caching implementation...
Definition MooseFunctor.h:939

◆ getPoints()

virtual const std::vector< Point > & NearestPointBase< LayeredAverage , ElementIntegralVariableUserObject >::getPoints ( ) const
inlinevirtualinherited

Get the points at which the nearest operation is performed.

Returns
points

Definition at line 57 of file NearestPointBase.h.

57{ return _points; }

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

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

◆ gradDot() [2/6]

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

Definition at line 226 of file MooseFunctor.h.

969{
970 return evaluateGradDot(elem_point, state);
971}

◆ gradDot() [3/6]

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

Definition at line 224 of file MooseFunctor.h.

955{
956 return evaluateGradDot(elem_qp, state);
957}

◆ gradDot() [4/6]

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

Definition at line 225 of file MooseFunctor.h.

962{
963 return evaluateGradDot(elem_side_qp, state);
964}

◆ gradDot() [5/6]

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

Definition at line 223 of file MooseFunctor.h.

947{
948 checkFace(face);
949 return evaluateGradDot(face, state);
950}

◆ gradDot() [6/6]

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

Definition at line 227 of file MooseFunctor.h.

976{
977 return evaluateGradDot(node, state);
978}

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

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

◆ gradient() [2/6]

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

Definition at line 200 of file MooseFunctor.h.

883{
884 return evaluateGradient(elem_point, state);
885}

◆ gradient() [3/6]

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

Definition at line 198 of file MooseFunctor.h.

869{
870 return evaluateGradient(elem_qp, state);
871}

◆ gradient() [4/6]

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

Definition at line 199 of file MooseFunctor.h.

876{
877 return evaluateGradient(elem_side_qp, state);
878}

◆ gradient() [5/6]

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

Definition at line 197 of file MooseFunctor.h.

861{
862 checkFace(face);
863 return evaluateGradient(face, state);
864}

◆ gradient() [6/6]

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

Definition at line 201 of file MooseFunctor.h.

890{
891 return evaluateGradient(node, state);
892}

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

134{
135 if constexpr (std::is_base_of<BlockRestrictable, UserObjectType>::value)
136 return UserObjectType::hasBlocks(sub_id);
137 else
138 return Moose::FunctorBase<Real>::hasBlocks(sub_id);
139}
Moose::FunctorBase::hasBlocks
virtual bool hasBlocks(SubdomainID) const
Returns whether the functor is defined on this block.
Definition MooseFunctor.h:243

◆ hasFaceSide()

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

Implements FaceArgInterface.

Reimplemented in InterfaceIntegralVariableValuePostprocessor, InternalSideIntegralVariablePostprocessor, SideIntegralFunctorPostprocessorTempl< is_ad >, SideIntegralFunctorPostprocessorTempl< false >, and SideIntegralVariablePostprocessor.

Definition at line 268 of file MooseFunctor.h.

983{
984 if (fi_elem_side)
985 return hasBlocks(fi.elem().subdomain_id());
986 else
987 return fi.neighborPtr() && hasBlocks(fi.neighbor().subdomain_id());
988}
FaceInfo::elem
const Elem & elem() const
Definition FaceInfo.h:85
FaceInfo::neighbor
const Elem & neighbor() const
Definition FaceInfo.h:220

◆ initialize()

void NearestPointBase< LayeredAverage , ElementIntegralVariableUserObject >::initialize ( )
overridevirtualinherited

Definition at line 39 of file NearestPointBase.h.

198{
199 for (auto & user_object : _user_objects)
200 user_object->initialize();
201}

◆ isConstant()

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

Returns true if this functor is a constant.

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.

Definition at line 253 of file MooseFunctor.h.

254 {
255 mooseError("not implemented");
256 }

◆ isInternalFace()

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

Returns true if the face is an internal face.

Definition at line 261 of file MooseFunctor.h.

576{
577 if (!fi.neighborPtr())
578 return false;
579
580 return hasBlocks(fi.elem().subdomain_id()) && hasBlocks(fi.neighborPtr()->subdomain_id());
581}

◆ jacobianSetup()

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

Implements Moose::FunctorAbstract.

Reimplemented in Function.

Definition at line 231 of file MooseFunctor.h.

838{
839 if (_clearance_schedule.count(EXEC_NONLINEAR))
840 clearCacheData();
841}
EXEC_NONLINEAR
const ExecFlagType EXEC_NONLINEAR
Definition Moose.C:33

◆ name()

const std::string & MooseBase::name ( ) const
inlineprotectedinherited

Get the name of the class.

Returns
The name of the class

Definition at line 88 of file MooseBase.h.

104 {
105 mooseAssert(_name.size(), "Empty name");
106 return _name;
107 }

◆ nearestUserObject()

LayeredAverage & NearestPointBase< LayeredAverage , ElementIntegralVariableUserObject >::nearestUserObject ( const Point &  p) const
protectedinherited

Get the UserObject that is closest to the point.

Parameters
pThe point.
Returns
The UserObject closest to p.

Definition at line 74 of file NearestPointBase.h.

238{
239 unsigned int closest = 0;
240 Real closest_distance = std::numeric_limits<Real>::max();
241
242 for (auto it : Moose::enumerate(_points))
243 {
244 const auto & current_point = it.value();
245
246 Real current_distance;
247 if (_dist_norm == 0)
248 // the distance is computed using standard norm
249 current_distance = (p - current_point).norm();
250 else
251 {
252 // the distance is to be computed based on radii
253 // in that case, we need to determine the 2 coordinate indices
254 // that define the radius
255 unsigned int i = 0;
256 unsigned int j = 1;
257
258 if (_axis == 0)
259 i = 2;
260 else if (_axis == 1)
261 j = 2;
262
263 current_distance = std::abs(
264 std::sqrt(p(i) * p(i) + p(j) * p(j)) -
265 std::sqrt(current_point(i) * current_point(i) + current_point(j) * current_point(j)));
266 }
267
268 if (current_distance < closest_distance)
269 {
270 closest_distance = current_distance;
271 closest = it.index();
272 }
273 }
274
275 return *_user_objects[closest];
276}
Moose
MOOSE now contains C++17 code, so give a reasonable error message stating what the user can do to add...
Definition SetAdaptivityOptionsAction.h:15
Moose::enumerate
_enumerate_range< Iterator > enumerate(Iterator first, Iterator last, typename std::iterator_traits< Iterator >::difference_type initial)
Enumerate function for iterating over a range and obtaining both a reference to the underlying type a...
Definition Enumerate.h:52
libMesh::TensorTools::norm
auto norm(const T &a)
libMesh::Real
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real

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

604{
605 if (_always_evaluate)
606 return evaluate(elem, state);
607
608 mooseAssert(state.state == 0,
609 "Cached evaluations are only currently supported for the current state.");
610
611 return queryFVArgCache(_elem_arg_to_value, elem);
612}
evaluate
T evaluate(Real, const Point &)
The general evaluation method is not defined.
Definition MooseParsedFunctionWrapper.h:144
Moose::FunctorBase< Real >::queryFVArgCache
ValueType queryFVArgCache(std::map< SpaceArg, ValueType > &cache_data, const SpaceArg &space) const
check a finite volume spatial argument cache and if invalid then evaluate
Definition MooseFunctor.h:586

◆ operator()() [2/6]

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

Definition at line 187 of file MooseFunctor.h.

714{
715 return evaluate(elem_point, state);
716}

◆ operator()() [3/6]

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

Definition at line 185 of file MooseFunctor.h.

663{
664 if (_always_evaluate)
665 return evaluate(elem_qp, state);
666
667 const auto elem_id = elem_qp.elem->id();
668 if (elem_id != _current_qp_map_key)
669 {
670 _current_qp_map_key = elem_id;
671 _current_qp_map_value = &_qp_to_value[elem_id];
672 }
673 auto & qp_data = *_current_qp_map_value;
674 const auto qp = elem_qp.qp;
675 const auto * const qrule = elem_qp.qrule;
676 mooseAssert(qrule, "qrule must be non-null");
677
678 return queryQpCache(qp, *qrule, qp_data, elem_qp, state);
679}
Moose::FunctorBase< Real >::queryQpCache
ValueType queryQpCache(unsigned int qp, const libMesh::QBase &qrule, std::vector< std::pair< bool, Real > > &qp_cache_data, const SpaceArg &space, const StateArg &state) const
check a qp cache and if invalid then evaluate
Definition MooseFunctor.h:632

◆ operator()() [4/6]

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

Definition at line 186 of file MooseFunctor.h.

684{
685 if (_always_evaluate)
686 return evaluate(elem_side_qp, state);
687
688 const Elem * const elem = elem_side_qp.elem;
689 mooseAssert(elem, "elem must be non-null");
690 const auto elem_id = elem->id();
691 if (elem_id != _current_side_qp_map_key)
692 {
693 _current_side_qp_map_key = elem_id;
694 _current_side_qp_map_value = &_side_qp_to_value[elem_id];
695 }
696 auto & side_qp_data = *_current_side_qp_map_value;
697 const auto side = elem_side_qp.side;
698 const auto qp = elem_side_qp.qp;
699 const auto * const qrule = elem_side_qp.qrule;
700 mooseAssert(qrule, "qrule must be non-null");
701
702 // Check and see whether we even have sized for this side
703 if (side >= side_qp_data.size())
704 side_qp_data.resize(elem->n_sides());
705
706 // Ok we were sized enough for our side
707 auto & qp_data = side_qp_data[side];
708 return queryQpCache(qp, *qrule, qp_data, elem_side_qp, state);
709}

◆ operator()() [5/6]

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

Definition at line 184 of file MooseFunctor.h.

617{
618 checkFace(face_in);
619
620 if (_always_evaluate)
621 return evaluate(face_in, state);
622
623 mooseAssert(state.state == 0,
624 "Cached evaluations are only currently supported for the current state.");
625
626 return queryFVArgCache(_face_arg_to_value, face_in);
627}

◆ operator()() [6/6]

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

Definition at line 188 of file MooseFunctor.h.

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

◆ queryFVArgCache()

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

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

Definition at line 516 of file MooseFunctor.h.

588{
589 // We don't want to evaluate if the key already exists, so instead we value initialize
590 auto [it, inserted] = cache_data.try_emplace(space, ValueType());
591 auto & value = it->second;
592
593 if (inserted)
594 // value not ready to go
595 // this function is only called from functions that assert we are in the current time state
596 value = evaluate(space, currentState());
597
598 return value;
599}
Moose::currentState
StateArg currentState()
Definition MooseFunctorArguments.h:156
libMesh::JacobiPolynomials::value
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)

◆ queryQpCache()

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

check a qp cache and if invalid then evaluate

Definition at line 506 of file MooseFunctor.h.

637{
638 // Check and see whether we even have sized for this quadrature point. If we haven't then we
639 // must evaluate
640 if (qp >= qp_cache_data.size())
641 {
642 qp_cache_data.resize(qrule.n_points(), std::make_pair(false, ValueType()));
643 auto & pr = qp_cache_data[qp];
644 pr.second = evaluate(space, state);
645 pr.first = true;
646 return pr.second;
647 }
648
649 // We've already sized for this qp, so let's see whether we have a valid cache value
650 auto & pr = qp_cache_data[qp];
651 if (pr.first)
652 return pr.second;
653
654 // No valid cache value so evaluate
655 pr.second = evaluate(space, state);
656 pr.first = true;
657 return pr.second;
658}
libMesh::QBase::n_points
unsigned int n_points() const

◆ residualSetup()

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

Implements Moose::FunctorAbstract.

Reimplemented in Function.

Definition at line 230 of file MooseFunctor.h.

830{
831 if (_clearance_schedule.count(EXEC_LINEAR))
832 clearCacheData();
833}
EXEC_LINEAR
const ExecFlagType EXEC_LINEAR
Definition Moose.C:31

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

721{
722 if (clearance_schedule.count(EXEC_ALWAYS))
723 _always_evaluate = true;
724
725 _clearance_schedule = clearance_schedule;
726}
EXEC_ALWAYS
const ExecFlagType EXEC_ALWAYS
Definition Moose.C:53
Moose::FunctorBase< Real >::_always_evaluate
bool _always_evaluate
Boolean to check if we always need evaluation.
Definition MooseFunctor.h:523

◆ spatialPoints()

const std::vector< Point > NearestPointBase< LayeredAverage , ElementIntegralVariableUserObject >::spatialPoints ( ) const
overridevirtualinherited

Definition at line 59 of file NearestPointBase.h.

281{
282 std::vector<Point> points;
283
284 for (MooseIndex(_points) i = 0; i < _points.size(); ++i)
285 {
286 auto layered_base = dynamic_cast<LayeredBase *>(_user_objects[i].get());
287 if (layered_base)
288 {
289 const auto & layers = layered_base->getLayerCenters();
290 auto direction = layered_base->direction();
291
292 for (const auto & l : layers)
293 {
294 Point pt = _points[i];
295 pt(direction) = l;
296 points.push_back(pt);
297 }
298 }
299 }
300
301 return points;
302}
LayeredBase
This base class computes volume integrals of a variable storing partial sums for the specified number...
Definition LayeredBase.h:37
LayeredBase::getLayerCenters
const std::vector< Real > & getLayerCenters() const
Get the center coordinates for the layers (along given direction)
Definition LayeredBase.h:67

◆ spatialValue()

Real NearestPointBase< LayeredAverage , ElementIntegralVariableUserObject >::spatialValue ( const Point &  p) const
overridevirtualinherited

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

Parameters
pThe point to look for in the layers.

Definition at line 51 of file NearestPointBase.h.

231{
232 return nearestUserObject(p).spatialValue(p);
233}
LayeredIntegralBase::spatialValue
virtual Real spatialValue(const Point &p) const override
Given a Point return the integral value associated with the layer that point falls in.
Definition LayeredIntegralBase.h:32

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

void NearestPointBase< LayeredAverage , ElementIntegralVariableUserObject >::threadJoin ( const UserObject &  y)
overridevirtualinherited

Definition at line 42 of file NearestPointBase.h.

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

◆ timestepSetup()

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

Implements Moose::FunctorAbstract.

Reimplemented in Function, MemoryUsage, and NumNonlinearIterations.

Definition at line 232 of file MooseFunctor.h.

822{
823 if (_clearance_schedule.count(EXEC_TIMESTEP_BEGIN))
824 clearCacheData();
825}
EXEC_TIMESTEP_BEGIN
const ExecFlagType EXEC_TIMESTEP_BEGIN
Definition Moose.C:37

◆ validParams()

InputParameters NearestRadiusLayeredAverage::validParams ( )
static

Definition at line 17 of file NearestRadiusLayeredAverage.C.

18{
19 InputParameters params =
20 NearestPointBase<LayeredAverage, ElementIntegralVariableUserObject>::validParams();
21
22 // this object sets 'dist_norm' so the user shouldn't input it
23 params.set<MooseEnum>("dist_norm") = "radius";
24 params.suppressParameter<MooseEnum>("dist_norm");
25
26 // 'direction' in this case corresponds to 'axis' so the user shouldn't input it
27 params.set<MooseEnum>("axis") = params.get<MooseEnum>("direction");
28 params.suppressParameter<MooseEnum>("axis");
29
30 params.addClassDescription(
31 "Computes averages of a variable storing partial sums for the specified number of intervals "
32 "in a direction (x,y,z). Given a list of points this object computes the layered average "
33 "closest to each one of those points, where the distance is computed in terms of radius (or "
34 "distance to the origin in the plane perpendicular to 'direction').");
35
36 return params;
37}
InputParameters
The main MOOSE class responsible for handling user-defined parameters in almost every MOOSE system.
Definition InputParameters.h:68
InputParameters::suppressParameter
void suppressParameter(const std::string &name)
This method suppresses an inherited parameter so that it isn't required or valid in the derived class...
Definition InputParameters.h:2123
InputParameters::get
std::vector< std::pair< R1, R2 > > get(const std::string &param1, const std::string &param2) const
Combine two vector parameters into a single vector of pairs.
Definition InputParameters.h:2342
InputParameters::addClassDescription
void addClassDescription(const std::string &doc_string)
This method adds a description of the class that will be displayed in the input file syntax dump.
Definition InputParameters.C:81
InputParameters::set
T & set(const std::string &name, bool quiet_mode=false)
Returns a writable reference to the named parameters.
Definition InputParameters.h:1596
MooseEnum
This is a "smart" enum class intended to replace many of the shortcomings in the C++ enum type It sho...
Definition MooseEnum.h:55
NearestPointBase::validParams
static InputParameters validParams()
Definition NearestPointBase.h:93

Member Data Documentation

◆ _always_evaluate

bool Moose::FunctorBase< Real >::_always_evaluate
privateinherited

Boolean to check if we always need evaluation.

Definition at line 523 of file MooseFunctor.h.

◆ _axis

const unsigned int NearestPointBase< LayeredAverage , ElementIntegralVariableUserObject >::_axis
protectedinherited

Definition at line 82 of file NearestPointBase.h.

◆ _clearance_schedule

std::set<ExecFlagType> Moose::FunctorBase< Real >::_clearance_schedule
privateinherited

How often to clear the material property cache.

Definition at line 520 of file MooseFunctor.h.

◆ _current_qp_map_key

dof_id_type Moose::FunctorBase< Real >::_current_qp_map_key
mutableprivateinherited

Current key for qp map cache.

Definition at line 529 of file MooseFunctor.h.

◆ _current_qp_map_value

std::vector<std::pair<bool, ValueType> >* Moose::FunctorBase< Real >::_current_qp_map_value
mutableprivateinherited

Current value for qp map cache.

Definition at line 532 of file MooseFunctor.h.

◆ _current_side_qp_map_key

dof_id_type Moose::FunctorBase< Real >::_current_side_qp_map_key
mutableprivateinherited

Current key for side-qp map cache.

Definition at line 545 of file MooseFunctor.h.

◆ _current_side_qp_map_value

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

Current value for side-qp map cache.

Definition at line 548 of file MooseFunctor.h.

◆ _dist_norm

const unsigned int NearestPointBase< LayeredAverage , ElementIntegralVariableUserObject >::_dist_norm
protectedinherited

Definition at line 80 of file NearestPointBase.h.

◆ _elem_arg_to_value

std::map<ElemArg, ValueType> Moose::FunctorBase< Real >::_elem_arg_to_value
mutableprivateinherited

Map from element arguments to their cached evaluations.

Definition at line 561 of file MooseFunctor.h.

◆ _face_arg_to_value

std::map<FaceArg, ValueType> Moose::FunctorBase< Real >::_face_arg_to_value
mutableprivateinherited

Map from face arguments to their cached evaluations.

Definition at line 564 of file MooseFunctor.h.

◆ _functor_name

MooseFunctorName Moose::FunctorBase< Real >::_functor_name
privateinherited

name of the functor

Definition at line 570 of file MooseFunctor.h.

◆ _node_arg_to_value

std::map<NodeArg, ValueType> Moose::FunctorBase< Real >::_node_arg_to_value
mutableprivateinherited

Map from nodal arguments to their cached evaluations.

Definition at line 567 of file MooseFunctor.h.

◆ _points

std::vector<Point> NearestPointBase< LayeredAverage , ElementIntegralVariableUserObject >::_points
protectedinherited

Definition at line 76 of file NearestPointBase.h.

◆ _qp_to_value

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

Cached element quadrature point functor property evaluations.

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

Definition at line 539 of file MooseFunctor.h.

◆ _side_qp_to_value

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

Cached element quadrature point functor property evaluations.

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

Definition at line 558 of file MooseFunctor.h.

◆ _user_objects

std::vector<std::unique_ptr<LayeredAverage > > NearestPointBase< LayeredAverage , ElementIntegralVariableUserObject >::_user_objects
protectedinherited

Definition at line 77 of file NearestPointBase.h.

The documentation for this class was generated from the following files:
Generated on Fri Aug 21 2026 13:36:26 for https://mooseframework.inl.gov by doxygen 1.9.8